file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.contained_non_tip_region | val contained_non_tip_region: mem -> mem -> rid -> Type0 | val contained_non_tip_region: mem -> mem -> rid -> Type0 | let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 83,
"end_line": 132,
"start_col": 15,
"start_line": 131
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Monotonic.HyperStack.mem ->
m1: FStar.Monotonic.HyperStack.mem ->
r: FStar.Monotonic.HyperHeap.rid
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_and",
"Prims.l_not",
"Prims.eq2",
"FStar.Monotonic.HyperStack.get_tip",
"FStar.HyperStack.ST.contained_region"
] | [] | false | false | false | true | true | let contained_non_tip_region: mem -> mem -> rid -> Type0 =
| fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r | false |
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.is_eternal_region | val is_eternal_region (r: rid) : Type0 | val is_eternal_region (r: rid) : Type0 | let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r)) | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 85,
"end_line": 307,
"start_col": 0,
"start_line": 306
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Monotonic.HyperHeap.rid -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_and",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_eternal_region_hs",
"Prims.l_or",
"Prims.eq2",
"FStar.Monotonic.HyperHeap.root",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred"
] | [] | false | false | false | true | true | let is_eternal_region (r: rid) : Type0 =
| HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r)) | false |
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.new_region_post_common | val new_region_post_common : r0: FStar.Monotonic.HyperHeap.rid ->
r1: FStar.Monotonic.HyperHeap.rid ->
m0: FStar.Monotonic.HyperStack.mem ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0 | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 360,
"start_col": 0,
"start_line": 355
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
r0: FStar.Monotonic.HyperHeap.rid ->
r1: FStar.Monotonic.HyperHeap.rid ->
m0: FStar.Monotonic.HyperStack.mem ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"FStar.Monotonic.HyperHeap.extends",
"FStar.Monotonic.HyperStack.fresh_region",
"Prims.eq2",
"FStar.Map.t",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.Map.upd",
"FStar.Monotonic.Heap.emp",
"FStar.Monotonic.HyperStack.get_tip",
"FStar.Monotonic.HyperStack.live_region",
"Prims.logical"
] | [] | false | false | false | true | true | let new_region_post_common (r0 r1: rid) (m0 m1: mem) =
| r1 `HS.extends` r0 /\ HS.fresh_region r1 m0 m1 /\ get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\ HS.live_region m0 r0 | false |
|
Steel.MonotonicReference.fst | Steel.MonotonicReference.witnessed | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
= MHR.witnessed r (lift_property fact) | {
"file_name": "lib/steel/Steel.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 78,
"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.MonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
module MHR = Steel.MonotonicHigherReference
module U = FStar.Universe
let raise_preorder (#a:Type0) (p:Preorder.preorder a)
: Preorder.preorder (U.raise_t a)
= fun (x0 x1:U.raise_t a) ->
p (U.downgrade_val x0) (U.downgrade_val x1)
let ref a p = MHR.ref (FStar.Universe.raise_t a) (raise_preorder p)
/// The standard points to separation logic predicate
let pts_to_sl (#a:Type) (#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
= MHR.pts_to_sl r f (hide (U.raise_val v))
/// Allocates a reference with value [x]. We have full permission on the newly
/// allocated reference.
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: SteelT (ref a p) emp (fun r -> pts_to r full_perm v)
= let r = MHR.alloc (raise_preorder p) (U.raise_val v) in
rewrite_slprop
(MHR.pts_to r full_perm (hide (U.raise_val v)))
(pts_to r full_perm v)
(fun _ -> ());
return r
/// Writes value [x] in the reference [r], as long as we have full ownership of [r]
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: Steel unit (pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires fun _ -> p v x /\ True)
(ensures fun _ _ _ -> True)
= MHR.write r (U.raise_val x);
rewrite_slprop
(MHR.pts_to _ _ _)
(pts_to r full_perm x)
(fun _ -> ())
let lift_property (#a:Type u#0) (p:property a)
: MHR.property (U.raise_t a)
= fun x -> p (U.downgrade_val x) | {
"checked_file": "/",
"dependencies": [
"Steel.MonotonicHigherReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.MonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"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.MonotonicReference.ref a p -> fact: Steel.MonotonicReference.property a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"Steel.MonotonicReference.ref",
"Steel.MonotonicReference.property",
"Steel.MonotonicHigherReference.witnessed",
"FStar.Universe.raise_t",
"Steel.MonotonicReference.raise_preorder",
"Steel.MonotonicReference.lift_property"
] | [] | false | false | false | false | true | let witnessed (#a: Type u#0) (#p: Preorder.preorder a) (r: ref a p) (fact: property a) =
| MHR.witnessed r (lift_property fact) | false |
Steel.MonotonicReference.fst | Steel.MonotonicReference.ref | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | let ref a p = MHR.ref (FStar.Universe.raise_t a) (raise_preorder p) | {
"file_name": "lib/steel/Steel.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 67,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | (*
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.MonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
module MHR = Steel.MonotonicHigherReference
module U = FStar.Universe
let raise_preorder (#a:Type0) (p:Preorder.preorder a)
: Preorder.preorder (U.raise_t a)
= fun (x0 x1:U.raise_t a) ->
p (U.downgrade_val x0) (U.downgrade_val x1) | {
"checked_file": "/",
"dependencies": [
"Steel.MonotonicHigherReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.MonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"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 | a: Type0 -> p: FStar.Preorder.preorder a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"Steel.MonotonicHigherReference.ref",
"FStar.Universe.raise_t",
"Steel.MonotonicReference.raise_preorder"
] | [] | false | false | false | true | true | let ref a p =
| MHR.ref (FStar.Universe.raise_t a) (raise_preorder p) | false |
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.deref_post | val deref_post : r: FStar.HyperStack.ST.mreference a rel ->
m0: FStar.Monotonic.HyperStack.mem ->
x: a ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let deref_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (m0:mem) (x:a) (m1:mem) =
m1 == m0 /\ m0 `contains` r /\ x == HyperStack.sel m0 r | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 423,
"start_col": 7,
"start_line": 422
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold
let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0
val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 None))
val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 (Some c)))
let ralloc_post (#a:Type) (#rel:preorder a) (i:rid) (init:a) (m0:mem)
(x:mreference a rel) (m1:mem) =
let region_i = get_hmap m0 `Map.sel` i in
as_ref x `Heap.unused_in` region_i /\
i `is_in` get_hmap m0 /\
i = frameOf x /\
m1 == upd m0 x init
val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
(*
* AR: 12/26: For a ref to be readable/writable/free-able,
* the client can either prove contains
* or give us enough so that we can use monotonicity to derive contains
*)
let is_live_for_rw_in (#a:Type) (#rel:preorder a) (r:mreference a rel) (m:mem) :Type0 =
(m `contains` r) \/
(let i = HS.frameOf r in
(is_eternal_region i \/ i `HS.is_above` get_tip m) /\
(not (is_mm r) \/ m `HS.contains_ref_in_its_region` r))
val rfree (#a:Type) (#rel:preorder a) (r:mreference a rel{HS.is_mm r /\ HS.is_heap_color (HS.color (HS.frameOf r))})
:ST unit (requires (fun m0 -> r `is_live_for_rw_in` m0))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold let assign_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a) (m0:mem) (_:unit) (m1:mem) =
m0 `contains` r /\ m1 == HyperStack.upd m0 r v
(**
* Assigns, provided that the reference exists.
* Guarantees the strongest low-level effect: Stack
*)
val op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a)
:STL unit (requires (fun m -> r `is_live_for_rw_in` m /\ rel (HS.sel m r) v))
(ensures (assign_post r v)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.HyperStack.ST.mreference a rel ->
m0: FStar.Monotonic.HyperStack.mem ->
x: a ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.eq2",
"FStar.Monotonic.HyperStack.contains",
"FStar.Monotonic.HyperStack.sel",
"Prims.logical"
] | [] | false | false | false | false | true | let deref_post (#a: Type) (#rel: preorder a) (r: mreference a rel) (m0: mem) (x: a) (m1: mem) =
| m1 == m0 /\ m0 `contains` r /\ x == HyperStack.sel m0 r | false |
|
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.modifies_none | val modifies_none : h0: FStar.Monotonic.HyperStack.mem -> h1: FStar.Monotonic.HyperStack.mem -> Prims.logical | let modifies_none (h0:mem) (h1:mem) = modifies Set.empty h0 h1 | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 433,
"start_col": 0,
"start_line": 433
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold
let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0
val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 None))
val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 (Some c)))
let ralloc_post (#a:Type) (#rel:preorder a) (i:rid) (init:a) (m0:mem)
(x:mreference a rel) (m1:mem) =
let region_i = get_hmap m0 `Map.sel` i in
as_ref x `Heap.unused_in` region_i /\
i `is_in` get_hmap m0 /\
i = frameOf x /\
m1 == upd m0 x init
val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
(*
* AR: 12/26: For a ref to be readable/writable/free-able,
* the client can either prove contains
* or give us enough so that we can use monotonicity to derive contains
*)
let is_live_for_rw_in (#a:Type) (#rel:preorder a) (r:mreference a rel) (m:mem) :Type0 =
(m `contains` r) \/
(let i = HS.frameOf r in
(is_eternal_region i \/ i `HS.is_above` get_tip m) /\
(not (is_mm r) \/ m `HS.contains_ref_in_its_region` r))
val rfree (#a:Type) (#rel:preorder a) (r:mreference a rel{HS.is_mm r /\ HS.is_heap_color (HS.color (HS.frameOf r))})
:ST unit (requires (fun m0 -> r `is_live_for_rw_in` m0))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold let assign_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a) (m0:mem) (_:unit) (m1:mem) =
m0 `contains` r /\ m1 == HyperStack.upd m0 r v
(**
* Assigns, provided that the reference exists.
* Guarantees the strongest low-level effect: Stack
*)
val op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a)
:STL unit (requires (fun m -> r `is_live_for_rw_in` m /\ rel (HS.sel m r) v))
(ensures (assign_post r v))
unfold let deref_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (m0:mem) (x:a) (m1:mem) =
m1 == m0 /\ m0 `contains` r /\ x == HyperStack.sel m0 r
(**
* Dereferences, provided that the reference exists.
* Guarantees the strongest low-level effect: Stack
*)
val op_Bang (#a:Type) (#rel:preorder a) (r:mreference a rel)
:Stack a (requires (fun m -> r `is_live_for_rw_in` m))
(ensures (deref_post r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | h0: FStar.Monotonic.HyperStack.mem -> h1: FStar.Monotonic.HyperStack.mem -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.HyperStack.modifies",
"FStar.Set.empty",
"FStar.Monotonic.HyperHeap.rid",
"Prims.logical"
] | [] | false | false | false | true | true | let modifies_none (h0 h1: mem) =
| modifies Set.empty h0 h1 | false |
|
Steel.MonotonicReference.fst | Steel.MonotonicReference.pts_to_sl | val pts_to_sl (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: slprop u#1 | val pts_to_sl (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: slprop u#1 | let pts_to_sl (#a:Type) (#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
= MHR.pts_to_sl r f (hide (U.raise_val v)) | {
"file_name": "lib/steel/Steel.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 46,
"end_line": 43,
"start_col": 0,
"start_line": 39
} | (*
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.MonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
module MHR = Steel.MonotonicHigherReference
module U = FStar.Universe
let raise_preorder (#a:Type0) (p:Preorder.preorder a)
: Preorder.preorder (U.raise_t a)
= fun (x0 x1:U.raise_t a) ->
p (U.downgrade_val x0) (U.downgrade_val x1)
let ref a p = MHR.ref (FStar.Universe.raise_t a) (raise_preorder p) | {
"checked_file": "/",
"dependencies": [
"Steel.MonotonicHigherReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.MonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"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.MonotonicReference.ref a p -> f: Steel.FractionalPermission.perm -> v: a
-> Steel.Memory.slprop | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"Steel.MonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.MonotonicHigherReference.pts_to_sl",
"FStar.Universe.raise_t",
"Steel.MonotonicReference.raise_preorder",
"FStar.Ghost.hide",
"FStar.Universe.raise_val",
"Steel.Memory.slprop"
] | [] | false | false | false | false | false | let pts_to_sl (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f: perm) (v: a) =
| MHR.pts_to_sl r f (hide (U.raise_val v)) | false |
Vale.X64.Memory_Sems.fsti | Vale.X64.Memory_Sems.coerce | val coerce (#b #a: Type) (x: a{a == b}) : b | val coerce (#b #a: Type) (x: a{a == b}) : b | let coerce (#b #a:Type) (x:a{a == b}) : b = x | {
"file_name": "vale/code/arch/x64/Vale.X64.Memory_Sems.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 33,
"start_col": 7,
"start_line": 33
} | module Vale.X64.Memory_Sems
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.Arch.MachineHeap_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.Lib.Seqs
module S = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
val same_domain (h:vale_heap) (m:S.machine_heap) : prop0
val lemma_same_domains (h:vale_heap) (m1:S.machine_heap) (m2:S.machine_heap) : Lemma
(requires same_domain h m1 /\ Set.equal (Map.domain m1) (Map.domain m2))
(ensures same_domain h m2)
val get_heap (h:vale_heap) : GTot (m:S.machine_heap{same_domain h m})
val upd_heap (h:vale_heap) (m:S.machine_heap{is_machine_heap_update (get_heap h) m}) : GTot vale_heap
//val lemma_upd_get_heap (h:vale_heap) : Lemma (upd_heap h (get_heap h) == h)
// [SMTPat (upd_heap h (get_heap h))]
val lemma_get_upd_heap (h:vale_heap) (m:S.machine_heap) : Lemma
(requires is_machine_heap_update (get_heap h) m)
(ensures get_heap (upd_heap h m) == m) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Memory_Sems.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a{a == b} -> b | Prims.Tot | [
"total"
] | [] | [
"Prims.eq2"
] | [] | false | false | false | false | false | let coerce (#b #a: Type) (x: a{a == b}) : b =
| x | false |
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.is_live_for_rw_in | val is_live_for_rw_in (#a: Type) (#rel: preorder a) (r: mreference a rel) (m: mem) : Type0 | val is_live_for_rw_in (#a: Type) (#rel: preorder a) (r: mreference a rel) (m: mem) : Type0 | let is_live_for_rw_in (#a:Type) (#rel:preorder a) (r:mreference a rel) (m:mem) :Type0 =
(m `contains` r) \/
(let i = HS.frameOf r in
(is_eternal_region i \/ i `HS.is_above` get_tip m) /\
(not (is_mm r) \/ m `HS.contains_ref_in_its_region` r)) | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 405,
"start_col": 0,
"start_line": 401
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold
let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0
val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 None))
val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 (Some c)))
let ralloc_post (#a:Type) (#rel:preorder a) (i:rid) (init:a) (m0:mem)
(x:mreference a rel) (m1:mem) =
let region_i = get_hmap m0 `Map.sel` i in
as_ref x `Heap.unused_in` region_i /\
i `is_in` get_hmap m0 /\
i = frameOf x /\
m1 == upd m0 x init
val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
(*
* AR: 12/26: For a ref to be readable/writable/free-able,
* the client can either prove contains
* or give us enough so that we can use monotonicity to derive contains | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.HyperStack.ST.mreference a rel -> m: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_or",
"FStar.Monotonic.HyperStack.contains",
"Prims.l_and",
"FStar.HyperStack.ST.is_eternal_region",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_above",
"FStar.Monotonic.HyperStack.get_tip",
"Prims.op_Negation",
"FStar.Monotonic.HyperStack.is_mm",
"FStar.Monotonic.HyperStack.contains_ref_in_its_region",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.HyperStack.frameOf"
] | [] | false | false | false | false | true | let is_live_for_rw_in (#a: Type) (#rel: preorder a) (r: mreference a rel) (m: mem) : Type0 =
| (m `contains` r) \/
(let i = HS.frameOf r in
(is_eternal_region i \/ i `HS.is_above` (get_tip m)) /\
(not (is_mm r) \/ m `HS.contains_ref_in_its_region` r)) | false |
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.is_freeable_heap_region | val is_freeable_heap_region (r: rid) : Type0 | val is_freeable_heap_region (r: rid) : Type0 | let is_freeable_heap_region (r:rid) : Type0 =
HS.is_heap_color (color r) /\ HS.rid_freeable r /\ witnessed (region_contains_pred r) | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 87,
"end_line": 564,
"start_col": 0,
"start_line": 563
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold
let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0
val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 None))
val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 (Some c)))
let ralloc_post (#a:Type) (#rel:preorder a) (i:rid) (init:a) (m0:mem)
(x:mreference a rel) (m1:mem) =
let region_i = get_hmap m0 `Map.sel` i in
as_ref x `Heap.unused_in` region_i /\
i `is_in` get_hmap m0 /\
i = frameOf x /\
m1 == upd m0 x init
val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
(*
* AR: 12/26: For a ref to be readable/writable/free-able,
* the client can either prove contains
* or give us enough so that we can use monotonicity to derive contains
*)
let is_live_for_rw_in (#a:Type) (#rel:preorder a) (r:mreference a rel) (m:mem) :Type0 =
(m `contains` r) \/
(let i = HS.frameOf r in
(is_eternal_region i \/ i `HS.is_above` get_tip m) /\
(not (is_mm r) \/ m `HS.contains_ref_in_its_region` r))
val rfree (#a:Type) (#rel:preorder a) (r:mreference a rel{HS.is_mm r /\ HS.is_heap_color (HS.color (HS.frameOf r))})
:ST unit (requires (fun m0 -> r `is_live_for_rw_in` m0))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold let assign_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a) (m0:mem) (_:unit) (m1:mem) =
m0 `contains` r /\ m1 == HyperStack.upd m0 r v
(**
* Assigns, provided that the reference exists.
* Guarantees the strongest low-level effect: Stack
*)
val op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a)
:STL unit (requires (fun m -> r `is_live_for_rw_in` m /\ rel (HS.sel m r) v))
(ensures (assign_post r v))
unfold let deref_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (m0:mem) (x:a) (m1:mem) =
m1 == m0 /\ m0 `contains` r /\ x == HyperStack.sel m0 r
(**
* Dereferences, provided that the reference exists.
* Guarantees the strongest low-level effect: Stack
*)
val op_Bang (#a:Type) (#rel:preorder a) (r:mreference a rel)
:Stack a (requires (fun m -> r `is_live_for_rw_in` m))
(ensures (deref_post r))
let modifies_none (h0:mem) (h1:mem) = modifies Set.empty h0 h1
// NS: This version is just fine; all the operation on mem are ghost
// and we can rig it so that mem just get erased at the end
(**
* Returns the current stack of heaps --- it should be erased
*)
val get (_:unit)
:Stack mem (requires (fun m -> True))
(ensures (fun m0 x m1 -> m0 == x /\ m1 == m0))
(**
* We can only recall refs with mm bit unset, not stack refs
*)
val recall (#a:Type) (#rel:preorder a) (r:mreference a rel{not (HS.is_mm r)})
:Stack unit (requires (fun m -> is_eternal_region (HS.frameOf r) \/ m `contains_region` (HS.frameOf r)))
(ensures (fun m0 _ m1 -> m0 == m1 /\ m1 `contains` r))
(**
* We can only recall eternal regions, not stack regions
*)
val recall_region (i:rid{is_eternal_region i})
:Stack unit (requires (fun m -> True))
(ensures (fun m0 _ m1 -> m0 == m1 /\ i `is_in` get_hmap m1))
val witness_region (i:rid)
:Stack unit (requires (fun m0 -> HS.is_eternal_region_hs i ==> i `is_in` get_hmap m0))
(ensures (fun m0 _ m1 -> m0 == m1 /\ witnessed (region_contains_pred i)))
val witness_hsref (#a:Type) (#rel:preorder a) (r:HS.mreference a rel)
:ST unit (fun h0 -> h0 `HS.contains` r)
(fun h0 _ h1 -> h0 == h1 /\ witnessed (ref_contains_pred r))
(** MR witness etc. **)
type erid = r:rid{is_eternal_region r}
type m_rref (r:erid) (a:Type) (b:preorder a) = x:mref a b{HS.frameOf x = r}
(* states that p is preserved by any valid updates on r; note that h0 and h1 may differ arbitrarily elsewhere, hence proving stability usually requires that p depends only on r's content.
*)
unfold type stable_on (#a:Type0) (#rel:preorder a) (p:mem_predicate) (r:mreference a rel)
= forall (h0 h1:mem).{:pattern (p h0); rel (HS.sel h0 r) (HS.sel h1 r)}
(p h0 /\ rel (HS.sel h0 r) (HS.sel h1 r)) ==> p h1
(*
* The stable_on_t and mr_witness API is here for legacy reasons,
* the preferred API is stable_on and witness_p
*)
unfold type stable_on_t (#i:erid) (#a:Type) (#b:preorder a)
(r:m_rref i a b) (p:mem_predicate)
= stable_on p r
val mr_witness (#r:erid) (#a:Type) (#b:preorder a)
(m:m_rref r a b) (p:mem_predicate)
:ST unit (requires (fun h0 -> p h0 /\ stable_on_t m p))
(ensures (fun h0 _ h1 -> h0==h1 /\ witnessed p))
val weaken_witness (p q:mem_predicate)
:Lemma ((forall h. p h ==> q h) /\ witnessed p ==> witnessed q)
val testify (p:mem_predicate)
:ST unit (requires (fun _ -> witnessed p))
(ensures (fun h0 _ h1 -> h0==h1 /\ p h1))
val testify_forall (#c:Type) (#p:(c -> mem -> Type0))
($s:squash (forall (x:c). witnessed (p x)))
:ST unit (requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0==h1 /\ (forall (x:c). p x h1)))
val testify_forall_region_contains_pred (#c:Type) (#p:(c -> GTot rid))
($s:squash (forall (x:c). witnessed (region_contains_pred (p x))))
:ST unit (requires (fun _ -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\
(forall (x:c). HS.is_eternal_region_hs (p x) ==> h1 `contains_region` (p x))))
(****** Begin: preferred API for witnessing and recalling predicates ******)
val token_p (#a:Type0) (#rel:preorder a) (r:mreference a rel) (p:mem_predicate) :Type0
val witness_p (#a:Type0) (#rel:preorder a) (r:mreference a rel) (p:mem_predicate)
:ST unit (fun h0 -> p h0 /\ p `stable_on` r)
(fun h0 _ h1 -> h0 == h1 /\ token_p r p)
val recall_p (#a:Type0) (#rel:preorder a) (r:mreference a rel) (p:mem_predicate)
:ST unit (fun h0 -> ((is_eternal_region (HS.frameOf r) /\ not (HS.is_mm r)) \/ h0 `HS.contains` r) /\ token_p r p)
(fun h0 _ h1 -> h0 == h1 /\ h0 `HS.contains` r /\ p h0)
val token_functoriality
(#a:Type0) (#rel:preorder a) (r:mreference a rel)
(p:mem_predicate{token_p r p}) (q:mem_predicate{forall (h:mem). p h ==> q h})
: Lemma (token_p r q)
(****** End: preferred API for witnessing and recalling predicates ******)
type ex_rid = erid
(****** logical properties of witnessed ******)
val lemma_witnessed_constant (p:Type0)
:Lemma (witnessed (fun (m:mem) -> p) <==> p)
val lemma_witnessed_nested (p:mem_predicate)
: Lemma (witnessed (fun (m:mem) -> witnessed p) <==> witnessed p)
val lemma_witnessed_and (p q:mem_predicate)
:Lemma (witnessed (fun s -> p s /\ q s) <==> (witnessed p /\ witnessed q))
val lemma_witnessed_or (p q:mem_predicate)
:Lemma ((witnessed p \/ witnessed q) ==> witnessed (fun s -> p s \/ q s))
val lemma_witnessed_impl (p q:mem_predicate)
:Lemma ((witnessed (fun s -> p s ==> q s) /\ witnessed p) ==> witnessed q)
val lemma_witnessed_forall (#t:Type) (p:(t -> mem_predicate))
:Lemma ((witnessed (fun s -> forall x. p x s)) <==> (forall x. witnessed (p x)))
val lemma_witnessed_exists (#t:Type) (p:(t -> mem_predicate))
:Lemma ((exists x. witnessed (p x)) ==> witnessed (fun s -> exists x. p x s))
(*** Support for dynamic regions ***) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Monotonic.HyperHeap.rid -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_and",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_heap_color",
"FStar.Monotonic.HyperHeap.color",
"FStar.Monotonic.HyperHeap.rid_freeable",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred"
] | [] | false | false | false | true | true | let is_freeable_heap_region (r: rid) : Type0 =
| HS.is_heap_color (color r) /\ HS.rid_freeable r /\ witnessed (region_contains_pred r) | false |
Steel.MonotonicReference.fst | Steel.MonotonicReference.lift_property | val lift_property (#a: Type u#0) (p: property a) : MHR.property (U.raise_t a) | val lift_property (#a: Type u#0) (p: property a) : MHR.property (U.raise_t a) | let lift_property (#a:Type u#0) (p:property a)
: MHR.property (U.raise_t a)
= fun x -> p (U.downgrade_val x) | {
"file_name": "lib/steel/Steel.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 72,
"start_col": 0,
"start_line": 70
} | (*
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.MonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
module MHR = Steel.MonotonicHigherReference
module U = FStar.Universe
let raise_preorder (#a:Type0) (p:Preorder.preorder a)
: Preorder.preorder (U.raise_t a)
= fun (x0 x1:U.raise_t a) ->
p (U.downgrade_val x0) (U.downgrade_val x1)
let ref a p = MHR.ref (FStar.Universe.raise_t a) (raise_preorder p)
/// The standard points to separation logic predicate
let pts_to_sl (#a:Type) (#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
= MHR.pts_to_sl r f (hide (U.raise_val v))
/// Allocates a reference with value [x]. We have full permission on the newly
/// allocated reference.
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: SteelT (ref a p) emp (fun r -> pts_to r full_perm v)
= let r = MHR.alloc (raise_preorder p) (U.raise_val v) in
rewrite_slprop
(MHR.pts_to r full_perm (hide (U.raise_val v)))
(pts_to r full_perm v)
(fun _ -> ());
return r
/// Writes value [x] in the reference [r], as long as we have full ownership of [r]
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: Steel unit (pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires fun _ -> p v x /\ True)
(ensures fun _ _ _ -> True)
= MHR.write r (U.raise_val x);
rewrite_slprop
(MHR.pts_to _ _ _)
(pts_to r full_perm x)
(fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"Steel.MonotonicHigherReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.MonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"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.MonotonicReference.property a
-> Steel.MonotonicHigherReference.property (FStar.Universe.raise_t a) | Prims.Tot | [
"total"
] | [] | [
"Steel.MonotonicReference.property",
"FStar.Universe.raise_t",
"FStar.Universe.downgrade_val",
"Prims.prop",
"Steel.MonotonicHigherReference.property"
] | [] | false | false | false | true | false | let lift_property (#a: Type u#0) (p: property a) : MHR.property (U.raise_t a) =
| fun x -> p (U.downgrade_val x) | false |
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.salloc_post | val salloc_post : init: a ->
m0: FStar.Monotonic.HyperStack.mem ->
s:
FStar.HyperStack.ST.mreference a rel
{FStar.Monotonic.HyperStack.is_stack_region (FStar.Monotonic.HyperStack.frameOf s)} ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 332,
"start_col": 0,
"start_line": 325
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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": 40,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
init: a ->
m0: FStar.Monotonic.HyperStack.mem ->
s:
FStar.HyperStack.ST.mreference a rel
{FStar.Monotonic.HyperStack.is_stack_region (FStar.Monotonic.HyperStack.frameOf s)} ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.mreference",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_stack_region",
"FStar.Monotonic.HyperStack.frameOf",
"Prims.l_and",
"FStar.Monotonic.HyperStack.get_tip",
"Prims.eq2",
"FStar.Set.set",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Map.domain",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"Prims.op_Equality",
"FStar.Monotonic.HyperStack.fresh_ref",
"FStar.Monotonic.HyperStack.upd",
"Prims.logical"
] | [] | false | false | false | false | true | let salloc_post
(#a: Type)
(#rel: preorder a)
(init: a)
(m0: mem)
(s: mreference a rel {is_stack_region (frameOf s)})
(m1: mem)
=
| is_stack_region (get_tip m0) /\ Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\ frameOf s = get_tip m1 /\ HS.fresh_ref s m0 m1 /\
m1 == HyperStack.upd m0 s init | false |
|
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.assign_post | val assign_post : r: FStar.HyperStack.ST.mreference a rel ->
v: a ->
m0: FStar.Monotonic.HyperStack.mem ->
_: Prims.unit ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let assign_post (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a) (m0:mem) (_:unit) (m1:mem) =
m0 `contains` r /\ m1 == HyperStack.upd m0 r v | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 412,
"start_col": 7,
"start_line": 411
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold
let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0
val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 None))
val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 (Some c)))
let ralloc_post (#a:Type) (#rel:preorder a) (i:rid) (init:a) (m0:mem)
(x:mreference a rel) (m1:mem) =
let region_i = get_hmap m0 `Map.sel` i in
as_ref x `Heap.unused_in` region_i /\
i `is_in` get_hmap m0 /\
i = frameOf x /\
m1 == upd m0 x init
val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init))
(*
* AR: 12/26: For a ref to be readable/writable/free-able,
* the client can either prove contains
* or give us enough so that we can use monotonicity to derive contains
*)
let is_live_for_rw_in (#a:Type) (#rel:preorder a) (r:mreference a rel) (m:mem) :Type0 =
(m `contains` r) \/
(let i = HS.frameOf r in
(is_eternal_region i \/ i `HS.is_above` get_tip m) /\
(not (is_mm r) \/ m `HS.contains_ref_in_its_region` r))
val rfree (#a:Type) (#rel:preorder a) (r:mreference a rel{HS.is_mm r /\ HS.is_heap_color (HS.color (HS.frameOf r))})
:ST unit (requires (fun m0 -> r `is_live_for_rw_in` m0))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.HyperStack.ST.mreference a rel ->
v: a ->
m0: FStar.Monotonic.HyperStack.mem ->
_: Prims.unit ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.Monotonic.HyperStack.mem",
"Prims.unit",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"Prims.eq2",
"FStar.Monotonic.HyperStack.upd",
"Prims.logical"
] | [] | false | false | false | false | true | let assign_post
(#a: Type)
(#rel: preorder a)
(r: mreference a rel)
(v: a)
(m0: mem)
(_: unit)
(m1: mem)
=
| m0 `contains` r /\ m1 == HyperStack.upd m0 r v | false |
|
Vale.X64.Memory_Sems.fsti | Vale.X64.Memory_Sems.is_full_update | val is_full_update : vfh: Vale.X64.Memory.vale_full_heap ->
h': Vale.X64.Memory.vale_heap ->
hid: Vale.X64.Memory.heaplet_id ->
mh': Vale.Arch.MachineHeap_s.machine_heap ->
mt': Vale.X64.Memory.memtaint
-> Prims.logical | let is_full_update (vfh:vale_full_heap) (h':vale_heap) (hid:heaplet_id) (mh':machine_heap) (mt':memtaint) =
is_machine_heap_update (heap_get (coerce vfh)) mh' /\ (
let vfh' = coerce (heap_upd (coerce vfh) mh' mt') in
mem_inv vfh' /\
vfh'.vf_layout == vfh.vf_layout /\
vfh'.vf_heaplets == Map16.upd vfh.vf_heaplets hid h'
) | {
"file_name": "vale/code/arch/x64/Vale.X64.Memory_Sems.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 56,
"start_col": 0,
"start_line": 50
} | module Vale.X64.Memory_Sems
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.Arch.MachineHeap_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.Lib.Seqs
module S = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
val same_domain (h:vale_heap) (m:S.machine_heap) : prop0
val lemma_same_domains (h:vale_heap) (m1:S.machine_heap) (m2:S.machine_heap) : Lemma
(requires same_domain h m1 /\ Set.equal (Map.domain m1) (Map.domain m2))
(ensures same_domain h m2)
val get_heap (h:vale_heap) : GTot (m:S.machine_heap{same_domain h m})
val upd_heap (h:vale_heap) (m:S.machine_heap{is_machine_heap_update (get_heap h) m}) : GTot vale_heap
//val lemma_upd_get_heap (h:vale_heap) : Lemma (upd_heap h (get_heap h) == h)
// [SMTPat (upd_heap h (get_heap h))]
val lemma_get_upd_heap (h:vale_heap) (m:S.machine_heap) : Lemma
(requires is_machine_heap_update (get_heap h) m)
(ensures get_heap (upd_heap h m) == m)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
val lemma_heap_impl : squash (heap_impl == vale_full_heap)
val lemma_heap_get_heap (h:vale_full_heap) : Lemma
(heap_get (coerce h) == get_heap (get_vale_heap h))
[SMTPat (heap_get (coerce h))]
val lemma_heap_taint (h:vale_full_heap) : Lemma
(heap_taint (coerce h) == full_heap_taint h)
[SMTPat (heap_taint (coerce h))]
let is_full_read (#t:base_typ) (h1 h2:vale_heap) (b:buffer t) (i:int) =
buffer_addr b h1 == buffer_addr b h2 /\
buffer_read b i h1 == buffer_read b i h2 /\
valid_buffer_read h1 b i // needed to trigger "index = i" in valid_mem_operand64/valid_mem_operand128 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Memory_Sems.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
vfh: Vale.X64.Memory.vale_full_heap ->
h': Vale.X64.Memory.vale_heap ->
hid: Vale.X64.Memory.heaplet_id ->
mh': Vale.Arch.MachineHeap_s.machine_heap ->
mt': Vale.X64.Memory.memtaint
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.vale_full_heap",
"Vale.X64.Memory.vale_heap",
"Vale.X64.Memory.heaplet_id",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.X64.Memory.memtaint",
"Prims.l_and",
"Vale.Arch.MachineHeap_s.is_machine_heap_update",
"Vale.Arch.Heap.heap_get",
"Vale.X64.Memory_Sems.coerce",
"Vale.Arch.Heap.heap_impl",
"Vale.X64.Memory.mem_inv",
"Prims.eq2",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_layout",
"Vale.Lib.Map16.map16",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heaplets",
"Vale.Lib.Map16.upd",
"Vale.Arch.HeapImpl.vale_full_heap",
"Vale.Arch.Heap.heap_upd",
"Prims.logical"
] | [] | false | false | false | true | true | let is_full_update
(vfh: vale_full_heap)
(h': vale_heap)
(hid: heaplet_id)
(mh': machine_heap)
(mt': memtaint)
=
| is_machine_heap_update (heap_get (coerce vfh)) mh' /\
(let vfh' = coerce (heap_upd (coerce vfh) mh' mt') in
mem_inv vfh' /\ vfh'.vf_layout == vfh.vf_layout /\
vfh'.vf_heaplets == Map16.upd vfh.vf_heaplets hid h') | false |
|
FStar.HyperStack.ST.fsti | FStar.HyperStack.ST.ralloc_post | val ralloc_post : i: FStar.Monotonic.HyperHeap.rid ->
init: a ->
m0: FStar.Monotonic.HyperStack.mem ->
x: FStar.HyperStack.ST.mreference a rel ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let ralloc_post (#a:Type) (#rel:preorder a) (i:rid) (init:a) (m0:mem)
(x:mreference a rel) (m1:mem) =
let region_i = get_hmap m0 `Map.sel` i in
as_ref x `Heap.unused_in` region_i /\
i `is_in` get_hmap m0 /\
i = frameOf x /\
m1 == upd m0 x init | {
"file_name": "ulib/FStar.HyperStack.ST.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 386,
"start_col": 0,
"start_line": 380
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.HyperStack.ST
open FStar.HyperStack
module HS = FStar.HyperStack
open FStar.Preorder
(* Setting up the preorder for mem *)
(* Starting the predicates that constitute the preorder *)
[@@"opaque_to_smt"]
private unfold let contains_region (m:mem) (r:rid) = get_hmap m `Map.contains` r
(* The preorder is the conjunction of above predicates *)
val mem_rel :preorder mem
type mem_predicate = mem -> Type0
(* Predicates that we will witness with regions and refs *)
val region_contains_pred (r:HS.rid) :mem_predicate
val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h mem
let gst_pre = st_pre_h mem
let gst_post' (a:Type) (pre:Type) = st_post_h' mem a pre
let gst_post (a:Type) = st_post_h mem a
let gst_wp (a:Type) = st_wp_h mem a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:mem) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
(*
* AR: A few notes about the interface:
* - The interface closely mimics the interface we formalized in our POPL'18 paper
* - Specifically, `witnessed` is defined for any mem_predicate (not necessarily stable ones)
* - `stable p` is a precondition for `gst_witness`
* - `gst_recall` does not have a precondition for `stable p`, since `gst_witness` is the only way
* clients would have obtained `witnessed p`, and so, `p` should already be stable
* - `lemma_functoriality` does not require stability for either `p` or `q`
* Our metatheory ensures that this is sound (without requiring stability of `q`)
* This form is useful in defining the MRRef interface (see mr_witness)
*)
val stable (p:mem_predicate) :Type0
val witnessed (p:mem_predicate) :Type0
(* TODO: we should derive these using DM4F *)
private val gst_get: unit -> GST mem (fun p h0 -> p h0 h0)
private val gst_put: h1:mem -> GST unit (fun p h0 -> mem_rel h0 h1 /\ p () h1)
private val gst_witness: p:mem_predicate -> GST unit (fun post h0 -> p h0 /\ stable p /\ (witnessed p ==> post () h0))
private val gst_recall: p:mem_predicate -> GST unit (fun post h0 -> witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST
unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp
sub_effect GST ~> STATE = lift_gst_state
(* effect State (a:Type) (wp:st_wp a) = *)
(* STATE a wp *)
(**
WARNING: this effect is unsafe, for C/C++ extraction it shall only be used by
code that would later extract to OCaml or by library functions
*)
effect Unsafe (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. pre h /\ post h a h1 ==> p a h1)) (* WP *)
(****** defining predicates for equal refs in some regions ******)
(*
// * AR: (may be this is an overkill)
// * various effects below talk about refs being equal in some regions (all regions, stack regions, etc.)
// * this was done by defining, for example, an equal_dom predicate with a (forall (r:rid)) quantifier
// * this quantifier was only guarded with Map.contains (HS.get_hmap m) r
// * which meant it could fire for all the contained regions
// *
// * instead now we define abstract predicates, e.g. same_refs_in_all_regions, and provide intro and elim forms
// * the advantage is that, the (lemma) quantifiers are now guarded additionally by same_refs_in_all_regions kind
// * of predicates, and hence should fire more contextually
// * should profile the queries to see if it actually helps
// *)
(*
// * marking these opaque, since expect them to be unfolded away beforehand
// *)
[@@"opaque_to_smt"]
unfold private let equal_heap_dom (r:rid) (m0 m1:mem) :Type0
= Heap.equal_dom (get_hmap m0 `Map.sel` r) (get_hmap m1 `Map.sel` r)
[@@"opaque_to_smt"]
unfold private let contained_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> m0 `contains_region` r /\ m1 `contains_region` r
[@@"opaque_to_smt"]
unfold private let contained_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> r =!= get_tip m0 /\ r =!= get_tip m1 /\ contained_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let contained_non_tip_stack_region :mem -> mem -> rid -> Type0
= fun m0 m1 r -> is_stack_region r /\ contained_non_tip_region m0 m1 r
[@@"opaque_to_smt"]
unfold private let same_refs_common (p:mem -> mem -> rid -> Type0) (m0 m1:mem) =
forall (r:rid). p m0 m1 r ==> equal_heap_dom r m0 m1
(* predicates *)
val same_refs_in_all_regions (m0 m1:mem) :Type0
val same_refs_in_stack_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_regions (m0 m1:mem) :Type0
val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0
(* intro and elim forms *)
val lemma_same_refs_in_all_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_region m0 m1)) (ensures (same_refs_in_all_regions m0 m1))
[SMTPat (same_refs_in_all_regions m0 m1)]
val lemma_same_refs_in_all_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_all_regions m0 m1 /\ contained_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_all_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_stack_region m0 m1)) (ensures (same_refs_in_stack_regions m0 m1))
[SMTPat (same_refs_in_stack_regions m0 m1)]
val lemma_same_refs_in_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_stack_regions m0 m1 /\ contained_stack_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_region m0 m1)) (ensures (same_refs_in_non_tip_regions m0 m1))
[SMTPat (same_refs_in_non_tip_regions m0 m1)]
val lemma_same_refs_in_non_tip_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_regions m0 m1 /\ contained_non_tip_region m0 m1 r)) (ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m0 `contains_region` r)];
[SMTPat (same_refs_in_non_tip_regions m0 m1); SMTPat (m1 `contains_region` r)]]]
val lemma_same_refs_in_non_tip_stack_regions_intro (m0 m1:mem)
:Lemma (requires (same_refs_common contained_non_tip_stack_region m0 m1)) (ensures (same_refs_in_non_tip_stack_regions m0 m1))
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1)]
val lemma_same_refs_in_non_tip_stack_regions_elim (m0 m1:mem) (r:rid)
:Lemma (requires (same_refs_in_non_tip_stack_regions m0 m1 /\ contained_non_tip_stack_region m0 m1 r))
(ensures (equal_heap_dom r m0 m1))
[SMTPatOr [[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m0 `contains_region` r);];
[SMTPat (same_refs_in_non_tip_stack_regions m0 m1); SMTPat (is_stack_region r); SMTPat (m1 `contains_region` r)]]]
(******)
let equal_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)) /\
same_refs_in_all_regions m0 m1
val lemma_equal_domains_trans (m0 m1 m2:mem)
:Lemma (requires (equal_domains m0 m1 /\ equal_domains m1 m2))
(ensures (equal_domains m0 m2))
[SMTPat (equal_domains m0 m1); SMTPat (equal_domains m1 m2)]
(**
* Effect of stacked based code: the 'equal_domains' clause enforces that
* - both mem have the same tip
* - both mem reference the same heaps (their map: rid -> heap have the same domain)
* - in each region id, the corresponding heaps contain the same references on both sides
*)
effect Stack (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_domains h h1) ==> p a h1)) (* WP *)
(**
* Effect of heap-based code.
* - assumes that the stack is empty (tip = root)
* - corresponds to the HyperHeap ST effect
* - can call to Stack and ST code freely
* - respects the stack invariant: the stack has to be empty when returning
*)
effect Heap (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ get_tip h = HS.root /\ get_tip h1 = HS.root ) ==> p a h1)) (* WP *)
let equal_stack_domains (m0 m1:mem) =
get_tip m0 == get_tip m1 /\
same_refs_in_stack_regions m0 m1
(**
* Effect of low-level code:
* - maintains the allocation invariant on the stack: no allocation unless in a new frame that has to be popped before returning
* - not constraints on heap allocation
*)
effect ST (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ equal_stack_domains h h1) ==> p a h1)) (* WP *)
effect St (a:Type) = ST a (fun _ -> True) (fun _ _ _ -> True)
let inline_stack_inv h h' : GTot Type0 =
(* The frame invariant is enforced *)
get_tip h == get_tip h' /\
(* The heap structure is unchanged *)
Map.domain (get_hmap h) == Map.domain (get_hmap h') /\
(* Any region that is not the tip has no seen any allocation *)
same_refs_in_non_tip_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect maintains the stack AND the heap invariant: it can be inlined in the Stack effect
* function body as well as in a Heap effect function body
*)
effect StackInline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ is_stack_region (get_tip h) /\ (forall a h1. (pre h /\ post h a h1 /\ inline_stack_inv h h1) ==> p a h1)) (* WP *)
let inline_inv h h' : GTot Type0 =
(* The stack invariant is enforced *)
get_tip h == get_tip h' /\
(* No frame may have received an allocation but the tip *)
same_refs_in_non_tip_stack_regions h h'
(**
* Effect that indicates to the Karamel compiler that allocation may occur in the caller's frame.
* In other terms, the backend has to unfold the body into the caller's body.
* This effect only maintains the stack invariant: the tip is left unchanged and no allocation
* may occurs in the stack lower than the tip.
* Region allocation is not constrained.
* Heap allocation is not constrained.
*)
effect Inline (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) =
STATE a
(fun (p:st_post a) (h:mem) -> pre h /\ (forall a h1. (pre h /\ post h a h1 /\ inline_inv h h1) ==> p a h1)) (* WP *)
(**
* TODO:
* REMOVE AS SOON AS CONSENSUS IS REACHED ON NEW LOW EFFECT NAMES
*)
effect STL (a:Type) (pre:st_pre) (post: (m0:mem -> Tot (st_post' a (pre m0)))) = Stack a pre post
sub_effect
DIV ~> STATE = fun (a:Type) (wp:pure_wp a) (p:st_post a) (h:mem) -> wp (fun a -> p a h)
(*
* AR: The clients should open HyperStack.ST after the memory model files (as with Heap and FStar.ST)
*)
type mreference (a:Type) (rel:preorder a) =
r:HS.mreference a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mstackref (a:Type) (rel:preorder a) =
r:HS.mstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mref (a:Type) (rel:preorder a) =
r:HS.mref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmstackref (a:Type) (rel:preorder a) =
r:HS.mmmstackref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type mmmref (a:Type) (rel:preorder a) =
r:HS.mmmref a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type s_mref (i:rid) (a:Type) (rel:preorder a) =
r:HS.s_mref i a rel{witnessed (ref_contains_pred r) /\
witnessed (region_contains_pred (HS.frameOf r))}
type reference (a:Type) = mreference a (Heap.trivial_preorder a)
type stackref (a:Type) = mstackref a (Heap.trivial_preorder a)
type ref (a:Type) = mref a (Heap.trivial_preorder a)
type mmstackref (a:Type) = mmmstackref a (Heap.trivial_preorder a)
type mmref (a:Type) = mmmref a (Heap.trivial_preorder a)
type s_ref (i:rid) (a:Type) = s_mref i a (Heap.trivial_preorder a)
let is_eternal_region (r:rid) :Type0
= HS.is_eternal_region_hs r /\ (r == HS.root \/ witnessed (region_contains_pred r))
(*
* AR: The change to using ST.rid may not be that bad itself,
* since subtyping should take care of most instances in the client usage.
* However, one case where it could be an issue is modifies clauses that use
* Set.set rid.
*)
(** Pushes a new empty frame on the stack **)
val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1))
(** Removes old frame from the stack **)
val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1))
#push-options "--z3rlimit 40"
let salloc_post (#a:Type) (#rel:preorder a) (init:a) (m0:mem)
(s:mreference a rel{is_stack_region (frameOf s)}) (m1:mem)
= is_stack_region (get_tip m0) /\
Map.domain (get_hmap m0) == Map.domain (get_hmap m1) /\
get_tip m0 == get_tip m1 /\
frameOf s = get_tip m1 /\
HS.fresh_ref s m0 m1 /\ //it's a fresh reference in the top frame
m1 == HyperStack.upd m0 s init //and it's been initialized
#pop-options
(**
* Allocates on the top-most stack frame
*)
val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
// JP, AR: these are not supported in C, and `salloc` already benefits from
// automatic memory management.
[@@ (deprecated "Use salloc instead") ]
val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init)
[@@ (deprecated "Use salloc instead") ]
val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0))
unfold
let new_region_post_common (r0 r1:rid) (m0 m1:mem) =
r1 `HS.extends` r0 /\
HS.fresh_region r1 m0 m1 /\
get_hmap m1 == Map.upd (get_hmap m0) r1 Heap.emp /\
get_tip m1 == get_tip m0 /\
HS.live_region m0 r0
val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 None))
val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 /\
(r1, m1) == HS.new_eternal_region m0 r0 (Some c))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.HyperStack.ST.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Monotonic.HyperHeap.rid ->
init: a ->
m0: FStar.Monotonic.HyperStack.mem ->
x: FStar.HyperStack.ST.mreference a rel ->
m1: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.mreference",
"Prims.l_and",
"FStar.Monotonic.Heap.unused_in",
"FStar.Monotonic.HyperStack.as_ref",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_in",
"FStar.Monotonic.HyperStack.get_hmap",
"Prims.op_Equality",
"FStar.Monotonic.HyperStack.frameOf",
"Prims.eq2",
"FStar.Monotonic.HyperStack.upd",
"FStar.Monotonic.Heap.heap",
"FStar.Map.sel",
"Prims.logical"
] | [] | false | false | false | false | true | let ralloc_post
(#a: Type)
(#rel: preorder a)
(i: rid)
(init: a)
(m0: mem)
(x: mreference a rel)
(m1: mem)
=
| let region_i = (get_hmap m0) `Map.sel` i in
(as_ref x) `Heap.unused_in` region_i /\ i `is_in` (get_hmap m0) /\ i = frameOf x /\
m1 == upd m0 x init | false |
|
FStar.Seq.Properties.fsti | FStar.Seq.Properties.indexable | val indexable : s: FStar.Seq.Base.seq a -> j: Prims.int -> Prims.logical | let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 25,
"start_col": 0,
"start_line": 25
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a -> j: Prims.int -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.logical"
] | [] | false | false | false | true | true | let indexable (#a: Type) (s: Seq.seq a) (j: int) =
| 0 <= j /\ j < Seq.length s | false |
|
FStar.Seq.Properties.fsti | FStar.Seq.Properties.mem | val mem (#a: eqtype) (x: a) (l: seq a) : Tot bool | val mem (#a: eqtype) (x: a) (l: seq a) : Tot bool | let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0 | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 77,
"start_col": 0,
"start_line": 77
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> l: FStar.Seq.Base.seq a -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.op_GreaterThan",
"FStar.Seq.Properties.count",
"Prims.bool"
] | [] | false | false | false | false | false | let mem (#a: eqtype) (x: a) (l: seq a) : Tot bool =
| count x l > 0 | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.snoc | val snoc (#a: Type) (s: seq a) (x: a) : Tot (seq a) | val snoc (#a: Type) (s: seq a) (x: a) : Tot (seq a) | let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 316,
"start_col": 0,
"start_line": 316
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a -> x: a -> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create"
] | [] | false | false | false | true | false | let snoc (#a: Type) (s: seq a) (x: a) : Tot (seq a) =
| Seq.append s (Seq.create 1 x) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.sortWith | val sortWith (#a: eqtype) (f: (a -> a -> Tot int)) (s: seq a) : Tot (seq a) | val sortWith (#a: eqtype) (f: (a -> a -> Tot int)) (s: seq a) : Tot (seq a) | let sortWith (#a:eqtype) (f:a -> a -> Tot int) (s:seq a) :Tot (seq a)
= seq_of_list (List.Tot.Base.sortWith f (seq_to_list s)) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 712,
"start_col": 0,
"start_line": 711
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *)
let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff)
val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))]
val head_cons
(#a: Type)
(x: a)
(s: seq a)
: Lemma
(ensures (head (cons x s) == x))
val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)]
val index_cons_l
(#a: Type)
(c: a)
(s: seq a)
: Lemma
(ensures (index (cons c s) 0 == c))
val index_cons_r
(#a: Type)
(c: a)
(s: seq a)
(i: nat {1 <= i /\ i <= length s})
: Lemma
(ensures (index (cons c s) i == index s (i - 1)))
val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2)))
val index_tail
(#a: Type)
(s: seq a {length s > 0})
(i: nat {i < length s - 1} )
: Lemma
(ensures (index (tail s) i == index s (i + 1)))
val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y))
val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))]
val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))]
val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)]
val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))]
val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)]
val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)]
[@@(deprecated "seq_of_list")]
let of_list (#a:Type) (l:list a) :seq a = seq_of_list l
val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l)))
val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))]
(** Dealing efficiently with `seq_of_list` by meta-evaluating conjunctions over
an entire list. *)
let rec explode_and (#a: Type)
(i: nat)
(s: seq a { i <= length s })
(l: list a { List.Tot.length l + i = length s }):
Tot Type
(decreases (List.Tot.length l))
= match l with
| [] -> True
| hd :: tl -> index s i == hd /\ explode_and (i + 1) s tl
unfold
let pointwise_and s l =
norm [ iota; zeta; primops; delta_only [ `%(explode_and) ] ] (explode_and 0 s l)
val intro_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
val intro_of_list (#a: Type) (s: seq a) (l: list a):
Lemma
(requires (
List.Tot.length l = length s /\
pointwise_and s l))
(ensures (
s == seq_of_list l))
val elim_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
val elim_of_list (#a: Type) (l: list a):
Lemma
(ensures (
let s = seq_of_list l in
pointwise_and s l)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: a -> _: a -> Prims.int) -> s: FStar.Seq.Base.seq a -> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Prims.int",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.seq_of_list",
"FStar.List.Tot.Base.sortWith",
"FStar.Seq.Base.seq_to_list"
] | [] | false | false | false | false | false | let sortWith (#a: eqtype) (f: (a -> a -> Tot int)) (s: seq a) : Tot (seq a) =
| seq_of_list (List.Tot.Base.sortWith f (seq_to_list s)) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.suffix_of | val suffix_of : s_suff: FStar.Seq.Base.seq a -> s: FStar.Seq.Base.seq a -> Prims.logical | let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 520,
"start_col": 0,
"start_line": 517
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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_suff: FStar.Seq.Base.seq a -> s: FStar.Seq.Base.seq a -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.l_Exists",
"Prims.eq2",
"FStar.Seq.Base.append",
"Prims.logical"
] | [] | false | false | false | true | true | let suffix_of (#a: Type) (s_suff s: seq a) =
| exists s_pref. (s == append s_pref s_suff) | false |
|
FStar.Seq.Properties.fsti | FStar.Seq.Properties.of_list | val of_list (#a: Type) (l: list a) : seq a | val of_list (#a: Type) (l: list a) : seq a | let of_list (#a:Type) (l:list a) :seq a = seq_of_list l | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 637,
"start_col": 0,
"start_line": 637
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *)
let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff)
val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))]
val head_cons
(#a: Type)
(x: a)
(s: seq a)
: Lemma
(ensures (head (cons x s) == x))
val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)]
val index_cons_l
(#a: Type)
(c: a)
(s: seq a)
: Lemma
(ensures (index (cons c s) 0 == c))
val index_cons_r
(#a: Type)
(c: a)
(s: seq a)
(i: nat {1 <= i /\ i <= length s})
: Lemma
(ensures (index (cons c s) i == index s (i - 1)))
val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2)))
val index_tail
(#a: Type)
(s: seq a {length s > 0})
(i: nat {i < length s - 1} )
: Lemma
(ensures (index (tail s) i == index s (i + 1)))
val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y))
val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))]
val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))]
val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)]
val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))]
val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)]
val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | l: Prims.list a -> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Seq.Base.seq_of_list",
"FStar.Seq.Base.seq"
] | [] | false | false | false | true | false | let of_list (#a: Type) (l: list a) : seq a =
| seq_of_list l | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.head | val head (#a: Type) (s: seq a {length s > 0}) : Tot a | val head (#a: Type) (s: seq a {length s > 0}) : Tot a | let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0 | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 40,
"start_col": 0,
"start_line": 40
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.index"
] | [] | false | false | false | false | false | let head (#a: Type) (s: seq a {length s > 0}) : Tot a =
| index s 0 | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.split_eq | val split_eq (#a: Type) (s: seq a) (i: nat{(0 <= i /\ i <= length s)})
: Pure (seq a * seq a) (requires True) (ensures (fun x -> (append (fst x) (snd x) == s))) | val split_eq (#a: Type) (s: seq a) (i: nat{(0 <= i /\ i <= length s)})
: Pure (seq a * seq a) (requires True) (ensures (fun x -> (append (fst x) (snd x) == s))) | let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 69,
"start_col": 0,
"start_line": 62
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a -> i: Prims.nat{0 <= i /\ i <= FStar.Seq.Base.length s}
-> Prims.Pure (FStar.Seq.Base.seq a * FStar.Seq.Base.seq a) | Prims.Pure | [] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.unit",
"FStar.Seq.Properties.lemma_split",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split",
"Prims.l_True",
"Prims.eq2",
"FStar.Seq.Base.append",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd"
] | [] | false | false | false | false | false | let split_eq (#a: Type) (s: seq a) (i: nat{(0 <= i /\ i <= length s)})
: Pure (seq a * seq a) (requires True) (ensures (fun x -> (append (fst x) (snd x) == s))) =
| let x = split s i in
lemma_split s i;
x | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.tail | val tail (#a: Type) (s: seq a {length s > 0}) : Tot (seq a) | val tail (#a: Type) (s: seq a {length s > 0}) : Tot (seq a) | let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 42,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice"
] | [] | false | false | false | false | false | let tail (#a: Type) (s: seq a {length s > 0}) : Tot (seq a) =
| slice s 1 (length s) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.split | val split (#a: Type) (s: seq a) (i: nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a) | val split (#a: Type) (s: seq a) (i: nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a) | let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 57,
"start_col": 0,
"start_line": 56
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a -> i: Prims.nat{0 <= i /\ i <= FStar.Seq.Base.length s}
-> FStar.Seq.Base.seq a * FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.slice",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let split (#a: Type) (s: seq a) (i: nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a) =
| slice s 0 i, slice s i (length s) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.pointwise_and | val pointwise_and : s: FStar.Seq.Base.seq _ {0 <= FStar.Seq.Base.length s} ->
l: Prims.list _ {FStar.List.Tot.Base.length l + 0 = FStar.Seq.Base.length s}
-> Type0 | let pointwise_and s l =
norm [ iota; zeta; primops; delta_only [ `%(explode_and) ] ] (explode_and 0 s l) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 670,
"start_col": 0,
"start_line": 669
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *)
let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff)
val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))]
val head_cons
(#a: Type)
(x: a)
(s: seq a)
: Lemma
(ensures (head (cons x s) == x))
val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)]
val index_cons_l
(#a: Type)
(c: a)
(s: seq a)
: Lemma
(ensures (index (cons c s) 0 == c))
val index_cons_r
(#a: Type)
(c: a)
(s: seq a)
(i: nat {1 <= i /\ i <= length s})
: Lemma
(ensures (index (cons c s) i == index s (i - 1)))
val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2)))
val index_tail
(#a: Type)
(s: seq a {length s > 0})
(i: nat {i < length s - 1} )
: Lemma
(ensures (index (tail s) i == index s (i + 1)))
val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y))
val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))]
val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))]
val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)]
val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))]
val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)]
val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)]
[@@(deprecated "seq_of_list")]
let of_list (#a:Type) (l:list a) :seq a = seq_of_list l
val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l)))
val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))]
(** Dealing efficiently with `seq_of_list` by meta-evaluating conjunctions over
an entire list. *)
let rec explode_and (#a: Type)
(i: nat)
(s: seq a { i <= length s })
(l: list a { List.Tot.length l + i = length s }):
Tot Type
(decreases (List.Tot.length l))
= match l with
| [] -> True
| hd :: tl -> index s i == hd /\ explode_and (i + 1) s tl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq _ {0 <= FStar.Seq.Base.length s} ->
l: Prims.list _ {FStar.List.Tot.Base.length l + 0 = FStar.Seq.Base.length s}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.list",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.iota",
"FStar.Pervasives.zeta",
"FStar.Pervasives.primops",
"FStar.Pervasives.delta_only",
"Prims.string",
"Prims.Nil",
"FStar.Seq.Properties.explode_and"
] | [] | false | false | false | false | true | let pointwise_and s l =
| norm [iota; zeta; primops; delta_only [`%(explode_and)]] (explode_and 0 s l) | false |
|
FStar.Seq.Properties.fsti | FStar.Seq.Properties.last | val last (#a: Type) (s: seq a {length s > 0}) : Tot a | val last (#a: Type) (s: seq a {length s > 0}) : Tot a | let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 50,
"start_col": 0,
"start_line": 50
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.index",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let last (#a: Type) (s: seq a {length s > 0}) : Tot a =
| index s (length s - 1) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.count | val count (#a: eqtype) (x: a) (s: seq a) : Tot nat (decreases (length s)) | val count (#a: eqtype) (x: a) (s: seq a) : Tot nat (decreases (length s)) | let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 75,
"start_col": 0,
"start_line": 71
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> s: FStar.Seq.Base.seq a -> Prims.Tot Prims.nat | Prims.Tot | [
"total",
""
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Properties.head",
"Prims.op_Addition",
"FStar.Seq.Properties.count",
"FStar.Seq.Properties.tail",
"Prims.nat"
] | [
"recursion"
] | false | false | false | false | false | let rec count (#a: eqtype) (x: a) (s: seq a) : Tot nat (decreases (length s)) =
| if length s = 0 then 0 else if head s = x then 1 + count x (tail s) else count x (tail s) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.replace_subseq | val replace_subseq
(#a: Type0)
(s: Seq.seq a)
(i: nat)
(j: nat{i <= j /\ j <= length s})
(sub: Seq.seq a {length sub == j - i})
: Tot (Seq.seq a) | val replace_subseq
(#a: Type0)
(s: Seq.seq a)
(i: nat)
(j: nat{i <= j /\ j <= length s})
(sub: Seq.seq a {length sub == j - i})
: Tot (Seq.seq a) | let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s))) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 256,
"start_col": 0,
"start_line": 255
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a ->
i: Prims.nat ->
j: Prims.nat{i <= j /\ j <= FStar.Seq.Base.length s} ->
sub: FStar.Seq.Base.seq a {FStar.Seq.Base.length sub == j - i}
-> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Seq.Base.append",
"FStar.Seq.Base.slice"
] | [] | false | false | false | false | false | let replace_subseq
(#a: Type0)
(s: Seq.seq a)
(i: nat)
(j: nat{i <= j /\ j <= length s})
(sub: Seq.seq a {length sub == j - i})
: Tot (Seq.seq a) =
| Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s))) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.index_mem | val index_mem (#a: eqtype) (x: a) (s: seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s)) | val index_mem (#a: eqtype) (x: a) (s: seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s)) | let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 92,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> s: FStar.Seq.Base.seq a -> Prims.Pure Prims.nat | Prims.Pure | [
""
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"FStar.Seq.Properties.head",
"Prims.bool",
"Prims.op_Addition",
"FStar.Seq.Properties.index_mem",
"FStar.Seq.Properties.tail",
"Prims.nat",
"Prims.b2t",
"FStar.Seq.Properties.mem",
"Prims.l_and",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index"
] | [
"recursion"
] | false | false | false | false | false | let rec index_mem (#a: eqtype) (x: a) (s: seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s)) =
| if head s = x then 0 else 1 + index_mem x (tail s) | false |
Steel.MonotonicReference.fst | Steel.MonotonicReference.raise_preorder | val raise_preorder (#a: Type0) (p: Preorder.preorder a) : Preorder.preorder (U.raise_t a) | val raise_preorder (#a: Type0) (p: Preorder.preorder a) : Preorder.preorder (U.raise_t a) | let raise_preorder (#a:Type0) (p:Preorder.preorder a)
: Preorder.preorder (U.raise_t a)
= fun (x0 x1:U.raise_t a) ->
p (U.downgrade_val x0) (U.downgrade_val x1) | {
"file_name": "lib/steel/Steel.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 50,
"end_line": 34,
"start_col": 0,
"start_line": 31
} | (*
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.MonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
module MHR = Steel.MonotonicHigherReference
module U = FStar.Universe | {
"checked_file": "/",
"dependencies": [
"Steel.MonotonicHigherReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.MonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"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: FStar.Preorder.preorder a -> FStar.Preorder.preorder (FStar.Universe.raise_t a) | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Universe.raise_t",
"FStar.Universe.downgrade_val"
] | [] | false | false | false | true | false | let raise_preorder (#a: Type0) (p: Preorder.preorder a) : Preorder.preorder (U.raise_t a) =
| fun (x0: U.raise_t a) (x1: U.raise_t a) -> p (U.downgrade_val x0) (U.downgrade_val x1) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.find_l | val find_l (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Tot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) | val find_l (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Tot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) | let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 338,
"start_col": 0,
"start_line": 333
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> Prims.bool) -> l: FStar.Seq.Base.seq a
-> Prims.Tot (o: FStar.Pervasives.Native.option a {Some? o ==> f (Some?.v o)}) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.None",
"FStar.Seq.Properties.head",
"FStar.Pervasives.Native.Some",
"FStar.Seq.Properties.find_l",
"FStar.Seq.Properties.tail",
"FStar.Pervasives.Native.option",
"Prims.l_imp",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.__proj__Some__item__v"
] | [
"recursion"
] | false | false | false | false | false | let rec find_l (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Tot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) =
| if Seq.length l = 0 then None else if f (head l) then Some (head l) else find_l f (tail l) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.sorted | val sorted (#a: Type) (f: (a -> a -> Tot bool)) (s: seq a) : Tot bool (decreases (length s)) | val sorted (#a: Type) (f: (a -> a -> Tot bool)) (s: seq a) : Tot bool (decreases (length s)) | let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 128,
"start_col": 0,
"start_line": 123
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: a -> _: a -> Prims.bool) -> s: FStar.Seq.Base.seq a -> Prims.Tot Prims.bool | Prims.Tot | [
"total",
""
] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.op_AmpAmp",
"FStar.Seq.Base.index",
"FStar.Seq.Properties.sorted",
"FStar.Seq.Properties.tail",
"FStar.Seq.Properties.head"
] | [
"recursion"
] | false | false | false | true | false | let rec sorted (#a: Type) (f: (a -> a -> Tot bool)) (s: seq a) : Tot bool (decreases (length s)) =
| if length s <= 1
then true
else
let hd = head s in
f hd (index s 1) && sorted f (tail s) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.swap | val swap (#a: Type) (s: seq a) (i: nat{i < length s}) (j: nat{j < length s}) : Tot (seq a) | val swap (#a: Type) (s: seq a) (i: nat{i < length s}) (j: nat{j < length s}) : Tot (seq a) | let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 95,
"start_col": 0,
"start_line": 94
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a ->
i: Prims.nat{i < FStar.Seq.Base.length s} ->
j: Prims.nat{j < FStar.Seq.Base.length s}
-> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.upd",
"FStar.Seq.Base.index"
] | [] | false | false | false | false | false | let swap (#a: Type) (s: seq a) (i: nat{i < length s}) (j: nat{j < length s}) : Tot (seq a) =
| upd (upd s j (index s i)) i (index s j) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.splice | val splice
(#a: Type)
(s1: seq a)
(i: nat)
(s2: seq a {length s1 = length s2})
(j: nat{i <= j /\ j <= (length s2)})
: Tot (seq a) | val splice
(#a: Type)
(s1: seq a)
(i: nat)
(s2: seq a {length s1 = length s2})
(j: nat{i <= j /\ j <= (length s2)})
: Tot (seq a) | let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1))) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 252,
"start_col": 0,
"start_line": 250
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
s1: FStar.Seq.Base.seq a ->
i: Prims.nat ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
j: Prims.nat{i <= j /\ j <= FStar.Seq.Base.length s2}
-> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.append",
"FStar.Seq.Base.slice"
] | [] | false | false | false | false | false | let splice
(#a: Type)
(s1: seq a)
(i: nat)
(s2: seq a {length s1 = length s2})
(j: nat{i <= j /\ j <= (length s2)})
: Tot (seq a) =
| Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1))) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.ghost_find_l | val ghost_find_l (#a: Type) (f: (a -> GTot bool)) (l: seq a)
: GTot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) | val ghost_find_l (#a: Type) (f: (a -> GTot bool)) (l: seq a)
: GTot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) | let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 345,
"start_col": 0,
"start_line": 340
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> Prims.GTot Prims.bool) -> l: FStar.Seq.Base.seq a
-> Prims.GTot (o: FStar.Pervasives.Native.option a {Some? o ==> f (Some?.v o)}) | Prims.GTot | [
"sometrivial",
""
] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.None",
"FStar.Seq.Properties.head",
"FStar.Pervasives.Native.Some",
"FStar.Seq.Properties.ghost_find_l",
"FStar.Seq.Properties.tail",
"FStar.Pervasives.Native.option",
"Prims.l_imp",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.__proj__Some__item__v"
] | [
"recursion"
] | false | false | false | false | false | let rec ghost_find_l (#a: Type) (f: (a -> GTot bool)) (l: seq a)
: GTot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) =
| if Seq.length l = 0 then None else if f (head l) then Some (head l) else ghost_find_l f (tail l) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.for_all | val for_all (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Pure bool
(requires True)
(ensures
(fun b -> (b == true <==> (forall (i: nat{i < Seq.length l}). f (index l i) == true)))) | val for_all (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Pure bool
(requires True)
(ensures
(fun b -> (b == true <==> (forall (i: nat{i < Seq.length l}). f (index l i) == true)))) | let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 419,
"start_col": 0,
"start_line": 412
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s)))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> Prims.bool) -> l: FStar.Seq.Base.seq a -> Prims.Pure Prims.bool | Prims.Pure | [] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Pervasives.Native.uu___is_None",
"FStar.Seq.Properties.seq_find",
"Prims.op_Negation",
"Prims.l_True",
"Prims.l_iff",
"Prims.eq2",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.index"
] | [] | false | false | false | false | false | let for_all (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Pure bool
(requires True)
(ensures
(fun b -> (b == true <==> (forall (i: nat{i < Seq.length l}). f (index l i) == true)))) =
| None? (seq_find (fun i -> not (f i)) l) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.seq_find | val seq_find (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Pure (option a)
(requires True)
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) | val seq_find (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Pure (option a)
(requires True)
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) | let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 406,
"start_col": 0,
"start_line": 399
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> Prims.bool) -> l: FStar.Seq.Base.seq a -> Prims.Pure (FStar.Pervasives.Native.option a) | Prims.Pure | [] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.seq_find_aux",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.option",
"Prims.l_True",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Negation",
"FStar.Seq.Base.index",
"Prims.l_and",
"Prims.l_Exists",
"FStar.Seq.Properties.found",
"Prims.eq2"
] | [] | false | false | false | false | false | let seq_find (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Pure (option a)
(requires True)
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) =
| seq_find_aux f l (Seq.length l) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.un_snoc | val un_snoc (#a: Type) (s: seq a {length s <> 0}) : Tot (r: (seq a * a){s == snoc (fst r) (snd r)}) | val un_snoc (#a: Type) (s: seq a {length s <> 0}) : Tot (r: (seq a * a){s == snoc (fst r) (snd r)}) | let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0 | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 368,
"start_col": 0,
"start_line": 365
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Base.seq a {FStar.Seq.Base.length s <> 0}
-> r:
(FStar.Seq.Base.seq a * a)
{ s ==
FStar.Seq.Properties.snoc (FStar.Pervasives.Native.fst r) (FStar.Pervasives.Native.snd r) } | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.index",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.split",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let un_snoc (#a: Type) (s: seq a {length s <> 0}) : Tot (r: (seq a * a){s == snoc (fst r) (snd r)}) =
| let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0 | false |
Steel.ST.PCMReference.fst | Steel.ST.PCMReference.witness' | val witness':
#inames: _ ->
#a: Type ->
#pcm: pcm a ->
r: ref a pcm ->
fact: stable_property pcm ->
v: erased a ->
fact_valid_compat fact v ->
Prims.unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames (pts_to r v) (fun _ -> pts_to r v) | val witness':
#inames: _ ->
#a: Type ->
#pcm: pcm a ->
r: ref a pcm ->
fact: stable_property pcm ->
v: erased a ->
fact_valid_compat fact v ->
Prims.unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames (pts_to r v) (fun _ -> pts_to r v) | let witness' (#inames: _) (#a:Type) (#pcm:pcm a)
(r:ref a pcm)
(fact:stable_property pcm)
(v:erased a)
(_:fact_valid_compat fact v)
()
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames (pts_to r v)
(fun _ -> pts_to r v)
= P.witness r fact v () | {
"file_name": "lib/steel/Steel.ST.PCMReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 23,
"end_line": 26,
"start_col": 0,
"start_line": 18
} | module Steel.ST.PCMReference
module C = Steel.ST.Coercions
module P = Steel.PCMReference
let read r v0 = C.coerce_steel (fun _ -> P.read r v0)
let write r v0 v1 = C.coerce_steel (fun _ -> P.write r v0 v1)
let alloc x = C.coerce_steel (fun _ -> P.alloc x)
let free r x = C.coerce_steel (fun _ -> P.free r x)
let split r v v0 v1 = C.coerce_ghost (fun _ -> P.split r v v0 v1)
let gather r v0 v1 = C.coerce_ghost (fun _ -> P.gather r v0 v1) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Coercions.fsti.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.PCMReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Steel.ST.Coercions",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Steel.Memory.ref a pcm ->
fact: Steel.Memory.stable_property pcm ->
v: FStar.Ghost.erased a ->
_: Steel.ST.PCMReference.fact_valid_compat fact v ->
_: Prims.unit
-> Steel.Effect.Atomic.SteelAtomicUT (Steel.Memory.witnessed r fact) | Steel.Effect.Atomic.SteelAtomicUT | [] | [] | [
"Steel.Memory.inames",
"FStar.PCM.pcm",
"Steel.Memory.ref",
"Steel.Memory.stable_property",
"FStar.Ghost.erased",
"Steel.ST.PCMReference.fact_valid_compat",
"Prims.unit",
"Steel.PCMReference.witness",
"FStar.Ghost.hide",
"Steel.Memory.witnessed",
"FStar.Ghost.reveal",
"Steel.ST.PCMReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let witness'
(#inames: _)
(#a: Type)
(#pcm: pcm a)
(r: ref a pcm)
(fact: stable_property pcm)
(v: erased a)
(_: fact_valid_compat fact v)
()
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames (pts_to r v) (fun _ -> pts_to r v) =
| P.witness r fact v () | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.foldr | val foldr (#a #b: Type) (f: (b -> a -> Tot a)) (s: seq b) (init: a) : Tot a (decreases (length s)) | val foldr (#a #b: Type) (f: (b -> a -> Tot a)) (s: seq b) (init: a) : Tot a (decreases (length s)) | let rec foldr (#a #b:Type) (f:b -> a -> Tot a) (s:seq b) (init:a)
: Tot a (decreases (length s))
= if length s = 0 then init
else f (head s) (foldr f (tail s) init) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 742,
"start_col": 0,
"start_line": 739
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *)
let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff)
val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))]
val head_cons
(#a: Type)
(x: a)
(s: seq a)
: Lemma
(ensures (head (cons x s) == x))
val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)]
val index_cons_l
(#a: Type)
(c: a)
(s: seq a)
: Lemma
(ensures (index (cons c s) 0 == c))
val index_cons_r
(#a: Type)
(c: a)
(s: seq a)
(i: nat {1 <= i /\ i <= length s})
: Lemma
(ensures (index (cons c s) i == index s (i - 1)))
val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2)))
val index_tail
(#a: Type)
(s: seq a {length s > 0})
(i: nat {i < length s - 1} )
: Lemma
(ensures (index (tail s) i == index s (i + 1)))
val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y))
val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))]
val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))]
val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)]
val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))]
val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)]
val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)]
[@@(deprecated "seq_of_list")]
let of_list (#a:Type) (l:list a) :seq a = seq_of_list l
val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l)))
val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))]
(** Dealing efficiently with `seq_of_list` by meta-evaluating conjunctions over
an entire list. *)
let rec explode_and (#a: Type)
(i: nat)
(s: seq a { i <= length s })
(l: list a { List.Tot.length l + i = length s }):
Tot Type
(decreases (List.Tot.length l))
= match l with
| [] -> True
| hd :: tl -> index s i == hd /\ explode_and (i + 1) s tl
unfold
let pointwise_and s l =
norm [ iota; zeta; primops; delta_only [ `%(explode_and) ] ] (explode_and 0 s l)
val intro_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
val intro_of_list (#a: Type) (s: seq a) (l: list a):
Lemma
(requires (
List.Tot.length l = length s /\
pointwise_and s l))
(ensures (
s == seq_of_list l))
val elim_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
val elim_of_list (#a: Type) (l: list a):
Lemma
(ensures (
let s = seq_of_list l in
pointwise_and s l))
(****** sortWith ******)
let sortWith (#a:eqtype) (f:a -> a -> Tot int) (s:seq a) :Tot (seq a)
= seq_of_list (List.Tot.Base.sortWith f (seq_to_list s))
val lemma_seq_to_list_permutation (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
val lemma_seq_of_list_permutation (#a:eqtype) (l:list a)
:Lemma (forall x. List.Tot.Base.count x l == count x (seq_of_list l))
val lemma_seq_of_list_sorted (#a:Type) (f:a -> a -> Tot bool) (l:list a)
:Lemma (requires (List.Tot.Properties.sorted f l)) (ensures (sorted f (seq_of_list l)))
val lemma_seq_sortwith_correctness (#a:eqtype) (f:a -> a -> Tot int) (s:seq a)
:Lemma (requires (total_order a (List.Tot.Base.bool_of_compare f)))
(ensures (let s' = sortWith f s in sorted (List.Tot.Base.bool_of_compare f) s' /\ permutation a s s'))
(* sort_lseq:
A wrapper of Seq.sortWith which proves that the output sequences
is a sorted permutation of the input sequence with the same length
*)
let sort_lseq (#a:eqtype) #n (f:tot_ord a) (s:lseq a n)
: s':lseq a n{sorted f s' /\ permutation a s s'} =
lemma_seq_sortwith_correctness (L.compare_of_bool f) s;
let s' = sortWith (L.compare_of_bool f) s in
perm_len s s';
sorted_feq f (L.bool_of_compare (L.compare_of_bool f)) s';
s' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: (_: b -> _: a -> a) -> s: FStar.Seq.Base.seq b -> init: a -> Prims.Tot a | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.foldr",
"FStar.Seq.Properties.tail"
] | [
"recursion"
] | false | false | false | true | false | let rec foldr (#a #b: Type) (f: (b -> a -> Tot a)) (s: seq b) (init: a)
: Tot a (decreases (length s)) =
| if length s = 0 then init else f (head s) (foldr f (tail s) init) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.createL | val createL (#a: Type0) (l: list a)
: Pure (seq a) (requires True) (ensures (fun s -> createL_post #a l s)) | val createL (#a: Type0) (l: list a)
: Pure (seq a) (requires True) (ensures (fun s -> createL_post #a l s)) | let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 453,
"start_col": 0,
"start_line": 447
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | l: Prims.list a -> Prims.Pure (FStar.Seq.Base.seq a) | Prims.Pure | [] | [] | [
"Prims.list",
"Prims.unit",
"FStar.Seq.Properties.lemma_list_seq_bij",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.length",
"FStar.Seq.Base.seq_of_list",
"Prims.l_True",
"FStar.Seq.Properties.createL_post"
] | [] | false | false | false | false | false | let createL (#a: Type0) (l: list a)
: Pure (seq a) (requires True) (ensures (fun s -> createL_post #a l s)) =
| let s = seq_of_list l in
lemma_list_seq_bij l;
s | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.foldr_snoc | val foldr_snoc (#a #b: Type) (f: (b -> a -> Tot a)) (s: seq b) (init: a)
: Tot a (decreases (length s)) | val foldr_snoc (#a #b: Type) (f: (b -> a -> Tot a)) (s: seq b) (init: a)
: Tot a (decreases (length s)) | let rec foldr_snoc (#a #b:Type) (f:b -> a -> Tot a) (s:seq b) (init:a)
: Tot a (decreases (length s))
= if length s = 0 then init
else let s, last = un_snoc s in
f last (foldr_snoc f s init) | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 748,
"start_col": 0,
"start_line": 744
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *)
let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff)
val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))]
val head_cons
(#a: Type)
(x: a)
(s: seq a)
: Lemma
(ensures (head (cons x s) == x))
val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)]
val index_cons_l
(#a: Type)
(c: a)
(s: seq a)
: Lemma
(ensures (index (cons c s) 0 == c))
val index_cons_r
(#a: Type)
(c: a)
(s: seq a)
(i: nat {1 <= i /\ i <= length s})
: Lemma
(ensures (index (cons c s) i == index s (i - 1)))
val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2)))
val index_tail
(#a: Type)
(s: seq a {length s > 0})
(i: nat {i < length s - 1} )
: Lemma
(ensures (index (tail s) i == index s (i + 1)))
val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y))
val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))]
val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))]
val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)]
val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))]
val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)]
val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)]
[@@(deprecated "seq_of_list")]
let of_list (#a:Type) (l:list a) :seq a = seq_of_list l
val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l)))
val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))]
(** Dealing efficiently with `seq_of_list` by meta-evaluating conjunctions over
an entire list. *)
let rec explode_and (#a: Type)
(i: nat)
(s: seq a { i <= length s })
(l: list a { List.Tot.length l + i = length s }):
Tot Type
(decreases (List.Tot.length l))
= match l with
| [] -> True
| hd :: tl -> index s i == hd /\ explode_and (i + 1) s tl
unfold
let pointwise_and s l =
norm [ iota; zeta; primops; delta_only [ `%(explode_and) ] ] (explode_and 0 s l)
val intro_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
val intro_of_list (#a: Type) (s: seq a) (l: list a):
Lemma
(requires (
List.Tot.length l = length s /\
pointwise_and s l))
(ensures (
s == seq_of_list l))
val elim_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
val elim_of_list (#a: Type) (l: list a):
Lemma
(ensures (
let s = seq_of_list l in
pointwise_and s l))
(****** sortWith ******)
let sortWith (#a:eqtype) (f:a -> a -> Tot int) (s:seq a) :Tot (seq a)
= seq_of_list (List.Tot.Base.sortWith f (seq_to_list s))
val lemma_seq_to_list_permutation (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
val lemma_seq_of_list_permutation (#a:eqtype) (l:list a)
:Lemma (forall x. List.Tot.Base.count x l == count x (seq_of_list l))
val lemma_seq_of_list_sorted (#a:Type) (f:a -> a -> Tot bool) (l:list a)
:Lemma (requires (List.Tot.Properties.sorted f l)) (ensures (sorted f (seq_of_list l)))
val lemma_seq_sortwith_correctness (#a:eqtype) (f:a -> a -> Tot int) (s:seq a)
:Lemma (requires (total_order a (List.Tot.Base.bool_of_compare f)))
(ensures (let s' = sortWith f s in sorted (List.Tot.Base.bool_of_compare f) s' /\ permutation a s s'))
(* sort_lseq:
A wrapper of Seq.sortWith which proves that the output sequences
is a sorted permutation of the input sequence with the same length
*)
let sort_lseq (#a:eqtype) #n (f:tot_ord a) (s:lseq a n)
: s':lseq a n{sorted f s' /\ permutation a s s'} =
lemma_seq_sortwith_correctness (L.compare_of_bool f) s;
let s' = sortWith (L.compare_of_bool f) s in
perm_len s s';
sorted_feq f (L.bool_of_compare (L.compare_of_bool f)) s';
s'
let rec foldr (#a #b:Type) (f:b -> a -> Tot a) (s:seq b) (init:a)
: Tot a (decreases (length s))
= if length s = 0 then init
else f (head s) (foldr f (tail s) init) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: (_: b -> _: a -> a) -> s: FStar.Seq.Base.seq b -> init: a -> Prims.Tot a | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Properties.foldr_snoc",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc"
] | [
"recursion"
] | false | false | false | true | false | let rec foldr_snoc (#a #b: Type) (f: (b -> a -> Tot a)) (s: seq b) (init: a)
: Tot a (decreases (length s)) =
| if length s = 0
then init
else
let s, last = un_snoc s in
f last (foldr_snoc f s init) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.createL_post | val createL_post (#a: Type0) (l: list a) (s: seq a) : GTot Type0 | val createL_post (#a: Type0) (l: list a) (s: seq a) : GTot Type0 | let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 445,
"start_col": 7,
"start_line": 444
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | l: Prims.list a -> s: FStar.Seq.Base.seq a -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"FStar.Seq.Base.seq",
"Prims.l_and",
"FStar.Pervasives.normalize",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.seq_to_list",
"FStar.Seq.Base.seq_of_list"
] | [] | false | false | false | false | true | let createL_post (#a: Type0) (l: list a) (s: seq a) : GTot Type0 =
| normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid' | val valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0 | val valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0 | let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos)) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 47,
"end_line": 23,
"start_col": 0,
"start_line": 12
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Base.parse"
] | [] | false | false | false | false | true | let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0 =
| U32.v pos <= U32.v s.len /\ live_slice h s /\ Some? (parse p (bytes_of_slice_from h s pos)) | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.find_r | val find_r (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Tot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) | val find_r (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Tot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) | let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 378,
"start_col": 0,
"start_line": 372
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> Prims.bool) -> l: FStar.Seq.Base.seq a
-> Prims.Tot (o: FStar.Pervasives.Native.option a {Some? o ==> f (Some?.v o)}) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Some",
"FStar.Seq.Properties.find_r",
"FStar.Pervasives.Native.option",
"Prims.l_imp",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc"
] | [
"recursion"
] | false | false | false | false | false | let rec find_r (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Tot (o: option a {Some? o ==> f (Some?.v o)}) (decreases (Seq.length l)) =
| if Seq.length l = 0
then None
else
let prefix, last = un_snoc l in
if f last then Some last else find_r f prefix | false |
FStar.Seq.Properties.fsti | FStar.Seq.Properties.seq_find_aux | val seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) | val seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) | let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 397,
"start_col": 0,
"start_line": 382
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 -> Prims.bool) -> l: FStar.Seq.Base.seq a -> ctr: Prims.nat{ctr <= FStar.Seq.Base.length l}
-> Prims.Pure (FStar.Pervasives.Native.option a) | Prims.Pure | [] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.None",
"Prims.int",
"FStar.Seq.Base.index",
"FStar.Pervasives.Native.Some",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Properties.found",
"FStar.Seq.Properties.seq_find_aux",
"FStar.Pervasives.Native.option",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Negation",
"Prims.l_Exists",
"Prims.eq2"
] | [
"recursion"
] | false | false | false | false | false | let rec seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) =
| match ctr with
| 0 -> None
| _ ->
let i = ctr - 1 in
if f (Seq.index l i)
then
(cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos | val valid_pos : p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.logical | let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 53,
"end_line": 260,
"start_col": 0,
"start_line": 250
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.content_length",
"Prims.logical"
] | [] | false | false | false | false | true | let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
=
| valid p h sl pos /\ U32.v pos + content_length p h sl pos == U32.v pos' | false |
|
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_content | val valid_content : p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t
-> Prims.logical | let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 26,
"end_line": 335,
"start_col": 0,
"start_line": 325
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents",
"Prims.logical"
] | [] | false | false | false | false | true | let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
=
| valid p h sl pos /\ contents p h sl pos == x | false |
|
FStar.Seq.Properties.fsti | FStar.Seq.Properties.sort_lseq | val sort_lseq (#a: eqtype) (#n: _) (f: tot_ord a) (s: lseq a n)
: s': lseq a n {sorted f s' /\ permutation a s s'} | val sort_lseq (#a: eqtype) (#n: _) (f: tot_ord a) (s: lseq a n)
: s': lseq a n {sorted f s' /\ permutation a s s'} | let sort_lseq (#a:eqtype) #n (f:tot_ord a) (s:lseq a n)
: s':lseq a n{sorted f s' /\ permutation a s s'} =
lemma_seq_sortwith_correctness (L.compare_of_bool f) s;
let s' = sortWith (L.compare_of_bool f) s in
perm_len s s';
sorted_feq f (L.bool_of_compare (L.compare_of_bool f)) s';
s' | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 737,
"start_col": 0,
"start_line": 731
} | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i
let seq_find (#a:Type) (f:a -> Tot bool) (l:seq a)
: Pure (option a)
(requires True)
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}).{:pattern (found i)}
found i /\ x == Seq.index l i)))
= seq_find_aux f l (Seq.length l)
val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s))))
let for_all
(#a: Type)
(f: (a -> Tot bool))
(l: seq a)
: Pure bool
(requires True)
(ensures (fun b -> (b == true <==> (forall (i: nat {i < Seq.length l} ) . f (index l i) == true))))
= None? (seq_find (fun i -> not (f i)) l)
val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)]
module L = FStar.List.Tot
val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl)))
val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
unfold let createL_post (#a:Type0) (l:list a) (s:seq a) : GTot Type0 =
normalize (L.length l = length s) /\ seq_to_list s == l /\ seq_of_list l == s
let createL (#a:Type0) (l:list a)
: Pure (seq a)
(requires True)
(ensures (fun s -> createL_post #a l s))
= let s = seq_of_list l in
lemma_list_seq_bij l;
s
val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
////////////////////////////////////////////////////////////////////////////////
//s `contains` x : Type0
// An undecidable version of `mem`,
// for when the sequence payload is not an eqtype
////////////////////////////////////////////////////////////////////////////////
[@@ remove_unused_type_parameters [0; 1; 2]]
val contains (#a:Type) (s:seq a) (x:a) : Tot Type0
val contains_intro (#a:Type) (s:seq a) (k:nat) (x:a)
: Lemma (k < Seq.length s /\ Seq.index s k == x
==>
s `contains` x)
val contains_elim (#a:Type) (s:seq a) (x:a)
: Lemma (s `contains` x
==>
(exists (k:nat). k < Seq.length s /\ Seq.index s k == x))
val lemma_contains_empty (#a:Type) : Lemma (forall (x:a). ~ (contains Seq.empty x))
val lemma_contains_singleton (#a:Type) (x:a) : Lemma (forall (y:a). contains (create 1 x) y ==> y == x)
val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x))
val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y))
val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x))
val append_cons_snoc (#a:Type) (u: Seq.seq a) (x:a) (v:Seq.seq a)
: Lemma (Seq.equal (Seq.append u (cons x v))
(Seq.append (snoc u x) v))
val append_slices (#a:Type) (s1:Seq.seq a) (s2:Seq.seq a)
: Lemma ( Seq.equal s1 (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) /\
Seq.equal s2 (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length s1 + Seq.length s2)) /\
(forall (i:nat) (j:nat).
i <= j /\ j <= Seq.length s2 ==>
Seq.equal (Seq.slice s2 i j)
(Seq.slice (Seq.append s1 s2) (Seq.length s1 + i) (Seq.length s1 + j))))
val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
(** More properties, with new naming conventions *)
let suffix_of
(#a: Type)
(s_suff s: seq a)
= exists s_pref . (s == append s_pref s_suff)
val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))]
val head_cons
(#a: Type)
(x: a)
(s: seq a)
: Lemma
(ensures (head (cons x s) == x))
val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)]
val index_cons_l
(#a: Type)
(c: a)
(s: seq a)
: Lemma
(ensures (index (cons c s) 0 == c))
val index_cons_r
(#a: Type)
(c: a)
(s: seq a)
(i: nat {1 <= i /\ i <= length s})
: Lemma
(ensures (index (cons c s) i == index s (i - 1)))
val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2)))
val index_tail
(#a: Type)
(s: seq a {length s > 0})
(i: nat {i < length s - 1} )
: Lemma
(ensures (index (tail s) i == index s (i + 1)))
val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y))
val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))]
val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))]
val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)]
val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))]
val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)]
val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)]
[@@(deprecated "seq_of_list")]
let of_list (#a:Type) (l:list a) :seq a = seq_of_list l
val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l)))
val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))]
(** Dealing efficiently with `seq_of_list` by meta-evaluating conjunctions over
an entire list. *)
let rec explode_and (#a: Type)
(i: nat)
(s: seq a { i <= length s })
(l: list a { List.Tot.length l + i = length s }):
Tot Type
(decreases (List.Tot.length l))
= match l with
| [] -> True
| hd :: tl -> index s i == hd /\ explode_and (i + 1) s tl
unfold
let pointwise_and s l =
norm [ iota; zeta; primops; delta_only [ `%(explode_and) ] ] (explode_and 0 s l)
val intro_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
val intro_of_list (#a: Type) (s: seq a) (l: list a):
Lemma
(requires (
List.Tot.length l = length s /\
pointwise_and s l))
(ensures (
s == seq_of_list l))
val elim_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
val elim_of_list (#a: Type) (l: list a):
Lemma
(ensures (
let s = seq_of_list l in
pointwise_and s l))
(****** sortWith ******)
let sortWith (#a:eqtype) (f:a -> a -> Tot int) (s:seq a) :Tot (seq a)
= seq_of_list (List.Tot.Base.sortWith f (seq_to_list s))
val lemma_seq_to_list_permutation (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
val lemma_seq_of_list_permutation (#a:eqtype) (l:list a)
:Lemma (forall x. List.Tot.Base.count x l == count x (seq_of_list l))
val lemma_seq_of_list_sorted (#a:Type) (f:a -> a -> Tot bool) (l:list a)
:Lemma (requires (List.Tot.Properties.sorted f l)) (ensures (sorted f (seq_of_list l)))
val lemma_seq_sortwith_correctness (#a:eqtype) (f:a -> a -> Tot int) (s:seq a)
:Lemma (requires (total_order a (List.Tot.Base.bool_of_compare f)))
(ensures (let s' = sortWith f s in sorted (List.Tot.Base.bool_of_compare f) s' /\ permutation a s s'))
(* sort_lseq:
A wrapper of Seq.sortWith which proves that the output sequences
is a sorted permutation of the input sequence with the same length | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: FStar.Seq.Properties.tot_ord a -> s: FStar.Seq.Properties.lseq a n
-> s':
FStar.Seq.Properties.lseq a n
{FStar.Seq.Properties.sorted f s' /\ FStar.Seq.Properties.permutation a s s'} | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Prims.nat",
"FStar.Seq.Properties.tot_ord",
"FStar.Seq.Properties.lseq",
"Prims.unit",
"FStar.Seq.Properties.sorted_feq",
"FStar.List.Tot.Base.bool_of_compare",
"FStar.List.Tot.Base.compare_of_bool",
"FStar.Seq.Properties.perm_len",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.sortWith",
"FStar.Seq.Properties.lemma_seq_sortwith_correctness",
"Prims.l_and",
"Prims.b2t",
"FStar.Seq.Properties.sorted",
"FStar.Seq.Properties.permutation"
] | [] | false | false | false | false | false | let sort_lseq (#a: eqtype) #n (f: tot_ord a) (s: lseq a n)
: s': lseq a n {sorted f s' /\ permutation a s s'} =
| lemma_seq_sortwith_correctness (L.compare_of_bool f) s;
let s' = sortWith (L.compare_of_bool f) s in
perm_len s s';
sorted_feq f (L.bool_of_compare (L.compare_of_bool f)) s';
s' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_content_pos | val valid_content_pos : p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t ->
pos': FStar.UInt32.t
-> Prims.logical | let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 348,
"start_col": 0,
"start_line": 337
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t ->
pos': FStar.UInt32.t
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Low.Base.Spec.valid_content",
"Prims.logical"
] | [] | false | false | false | false | true | let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos': U32.t)
=
| valid_pos p h sl pos pos' /\ valid_content p h sl pos x | false |
|
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_id | val clens_id (t: Type) : Tot (clens t t) | val clens_id (t: Type) : Tot (clens t t) | let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
} | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 957,
"start_col": 0,
"start_line": 954
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | t: Type -> LowParse.Low.Base.Spec.clens t t | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | true | false | let clens_id (t: Type) : Tot (clens t t) =
| { clens_cond = (fun _ -> True); clens_get = (fun x -> x) } | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_compose_strong_pre | val clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0 | val clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0 | let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 140,
"end_line": 1140,
"start_col": 0,
"start_line": 1133
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | l12: LowParse.Low.Base.Spec.clens t1 t2 -> l23: LowParse.Low.Base.Spec.clens t2 t3
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"Prims.l_Forall",
"Prims.l_imp",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | false | false | false | false | true | let clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0 =
| forall (x: t1). {:pattern (l12.clens_cond x)\/(l23.clens_cond (l12.clens_get x))}
l12.clens_cond x ==> l23.clens_cond (l12.clens_get x) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_elim | val valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos)) | val valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos)) | let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 72,
"start_col": 0,
"start_line": 60
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid p h s pos)
(ensures LowParse.Low.Base.Spec.valid' p h s pos) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_equiv",
"Prims.unit",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"LowParse.Low.Base.Spec.valid'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos)) =
| valid_equiv p h s pos | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_no_lookahead | val gaccessor_no_lookahead : f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl')) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 219,
"end_line": 1251,
"start_col": 0,
"start_line": 1242
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"Prims.l_imp",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.nat",
"Prims.logical"
] | [] | false | false | false | false | true | let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
=
| (k1.parser_kind_subkind == Some ParserStrong ==>
(forall (sl: bytes) (sl': bytes). {:pattern (f sl); (f sl')}
(gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==>
f sl == f sl')) | false |
|
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos_consumes_all | val valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len)) | val valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len)) | let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 24,
"end_line": 323,
"start_col": 0,
"start_line": 306
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h sl pos /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserConsumesAll)
(ensures LowParse.Low.Base.Spec.valid_pos p h sl pos (Mkslice?.len sl)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserConsumesAll",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len)) =
| parser_kind_prop_equiv k p;
valid_facts p h sl pos | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_pre | val gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0 | val gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0 | let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 1185,
"start_col": 0,
"start_line": 1173
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
cl: LowParse.Low.Base.Spec.clens t1 t2 ->
sl: LowParse.Bytes.bytes
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.l_False"
] | [] | false | false | false | false | true | let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0 =
| match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_compose_cond | val clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0 | val clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0 | let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 32,
"end_line": 1109,
"start_col": 0,
"start_line": 1101
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | l12: LowParse.Low.Base.Spec.clens t1 t2 -> clens_cond2: (_: t2 -> Prims.GTot Type0) -> x1: t1
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"Prims.l_and",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | false | false | false | false | true | let clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0 =
| l12.clens_cond x1 /\ clens_cond2 (l12.clens_get x1) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_elim | val valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos')) | val valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos')) | let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 449,
"start_col": 0,
"start_line": 436
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos') | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_exact p h s pos pos')
(ensures LowParse.Low.Base.Spec.valid_exact' p h s pos pos') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos')) =
| valid_exact_equiv p h s pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_elim' | val valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)] | val valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)] | let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 88,
"start_col": 0,
"start_line": 74
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid p h s pos)
(ensures
FStar.UInt32.v pos + Mkparser_kind'?.parser_kind_low k <= FStar.UInt32.v (Mkslice?.len s) /\
LowParse.Slice.live_slice h s)
[SMTPat (LowParse.Low.Base.Spec.valid p h s pos)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_equiv",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)] =
| parser_kind_prop_equiv k p;
valid_equiv p h s pos | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact' | val valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0 | val valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0 | let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 411,
"start_col": 0,
"start_line": 394
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos') | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.l_False",
"LowParse.Spec.Base.consumed_length",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.nat",
"Prims.logical",
"FStar.UInt32.sub"
] | [] | false | false | false | false | true | let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0 =
| U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ live_slice h s /\
(let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len') | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.contents' | val contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True)) | val contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True)) | let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 102,
"start_col": 0,
"start_line": 90
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.Ghost t | Prims.Ghost | [] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Slice.bytes_of_slice_from",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.valid'",
"Prims.l_True"
] | [] | false | false | false | false | false | let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True)) =
| let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_post' | val gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | val gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 66,
"end_line": 1224,
"start_col": 0,
"start_line": 1211
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
cl: LowParse.Low.Base.Spec.clens t1 t2 ->
sl: LowParse.Bytes.bytes ->
res: Prims.nat
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.l_imp",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Base.Spec.gaccessor_post"
] | [] | false | false | false | false | true | let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 =
| res <= Seq.length sl /\ (gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.contents_exact' | val contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True)) | val contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True)) | let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 489,
"start_col": 0,
"start_line": 476
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.Ghost t | Prims.Ghost | [] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.l_True"
] | [] | false | false | false | false | false | let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True)) =
| let Some (v, _) = parse p (bytes_of_slice_from_to h s pos pos') in
v | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.content_length_post | val content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)] | val content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)] | let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 216,
"start_col": 0,
"start_line": 197
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid p h sl pos)
(ensures
(let res = LowParse.Low.Base.Spec.content_length p h sl pos in
FStar.UInt32.v pos + res <= FStar.UInt32.v (Mkslice?.len sl) /\
Mkparser_kind'?.parser_kind_low k <= res /\
(match Mkparser_kind'?.parser_kind_high k with
| FStar.Pervasives.Native.None #_ -> Prims.l_True
| FStar.Pervasives.Native.Some #_ max -> res <= max)))
[SMTPat (LowParse.Low.Base.Spec.content_length p h sl pos)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.content_length_eq_gen",
"Prims.unit",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.l_True",
"Prims.nat",
"Prims.logical",
"LowParse.Low.Base.Spec.content_length",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)] =
| content_length_eq_gen p h sl pos | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.content_length' | val content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max))) | val content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max))) | let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 147,
"start_col": 0,
"start_line": 128
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"Prims.nat",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.valid'",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | false | false | let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max))) =
| let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_facts | val valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos))) | val valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos))) | let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 60,
"end_line": 234,
"start_col": 0,
"start_line": 218
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
(LowParse.Low.Base.Spec.valid p h sl pos <==> LowParse.Low.Base.Spec.valid' p h sl pos) /\
(LowParse.Low.Base.Spec.valid p h sl pos ==>
LowParse.Low.Base.Spec.contents p h sl pos == LowParse.Low.Base.Spec.contents' p h sl pos /\
LowParse.Low.Base.Spec.content_length p h sl pos ==
LowParse.Low.Base.Spec.content_length' p h sl pos)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid'",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Base.Spec.content_length'",
"LowParse.Low.Base.Spec.content_length_eq_gen",
"Prims.unit",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.contents'",
"LowParse.Low.Base.Spec.contents_eq",
"LowParse.Low.Base.Spec.valid_equiv",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos))) =
| valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos_frame_strong | val valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))) | val valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))) | let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 73,
"end_line": 786,
"start_col": 0,
"start_line": 765
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos') l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' \/
LowParse.Low.Base.Spec.valid_pos p h' sl pos pos' ==>
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
pos') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Low.Base.Spec.valid_pos",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.valid_pos_frame_strong_2",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_frame_strong_1",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))) =
| Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.bytes_of_slice_from_to | val bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True)) | val bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True)) | let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos') | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 56,
"end_line": 392,
"start_col": 0,
"start_line": 390
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.Ghost LowParse.Bytes.bytes | Prims.Ghost | [] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.l_True"
] | [] | false | false | false | false | false | let bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True)) =
| Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos') | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_injective | val gaccessor_injective : f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl') | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 163,
"end_line": 1281,
"start_col": 0,
"start_line": 1272
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.injective_precond",
"Prims.eq2",
"Prims.nat",
"Prims.logical"
] | [] | false | false | false | false | true | let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
=
| (forall (sl: bytes) (sl': bytes). {:pattern (f sl); (f sl')}
(gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==>
f sl == f sl') | false |
|
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos_valid_exact_pat | val valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | val valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 681,
"start_col": 0,
"start_line": 665
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_pos p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h s pos pos' ==
LowParse.Low.Base.Spec.contents p h s pos)
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos');
SMTPat (LowParse.Low.Base.Spec.valid p h s pos)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"LowParse.Low.Base.Spec.valid",
"Prims.Nil"
] | [] | true | false | true | false | false | let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] =
| valid_pos_valid_exact p h s pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_elim' | val valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')] | val valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')] | let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 474,
"start_col": 0,
"start_line": 451
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_exact p h s pos pos')
(ensures
LowParse.Slice.live_slice h s /\ FStar.UInt32.v pos <= FStar.UInt32.v pos' /\
FStar.UInt32.v pos' <= FStar.UInt32.v (Mkslice?.len s) /\
(let length = FStar.UInt32.v pos' - FStar.UInt32.v pos in
Mkparser_kind'?.parser_kind_low k <= length /\
(match Mkparser_kind'?.parser_kind_high k with
| FStar.Pervasives.Native.Some #_ high -> length <= high
| _ -> Prims.l_True)))
[SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos')] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"Prims.l_and",
"LowParse.Slice.live_slice",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.nat",
"FStar.Pervasives.Native.option",
"Prims.l_True",
"Prims.logical",
"Prims.int",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')] =
| parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_prop' | val gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0 | val gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0 | let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 51,
"end_line": 1293,
"start_col": 0,
"start_line": 1283
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl') | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_no_lookahead",
"LowParse.Low.Base.Spec.gaccessor_injective"
] | [] | false | false | false | false | true | let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0 =
| gaccessor_no_lookahead f /\ gaccessor_injective f | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_serialize | val valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos')) | val valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos')) | let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
() | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 4,
"end_line": 535,
"start_col": 0,
"start_line": 517
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_exact p h sl pos pos')
(ensures
LowParse.Spec.Base.serialize s (LowParse.Low.Base.Spec.contents_exact p h sl pos pos') ==
LowParse.Low.Base.Spec.bytes_of_slice_from_to h sl pos pos') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Spec.Base.serializer_correct_implies_complete",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos')) =
| valid_exact_equiv p h sl pos pos';
contents_exact_eq p h sl pos pos';
serializer_correct_implies_complete p s;
() | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.get_gaccessor_clens | val get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2) | val get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2) | let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 4,
"end_line": 1340,
"start_col": 0,
"start_line": 1330
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f }) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl -> LowParse.Low.Base.Spec.clens t1 t2 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | false | false | false | false | false | let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2) =
| cl | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_valid | val valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos')) | val valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos')) | let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 91,
"end_line": 700,
"start_col": 0,
"start_line": 683
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h
s
pos
(LowParse.Low.Base.Spec.contents_exact p h s pos pos')
pos') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos')) =
| valid_exact_equiv p h s pos pos';
contents_exact_eq p h s pos pos';
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_valid_pat | val valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | val valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 717,
"start_col": 0,
"start_line": 702
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h
s
pos
(LowParse.Low.Base.Spec.contents_exact p h s pos pos')
pos')
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos');
SMTPat (LowParse.Low.Base.Spec.valid p h s pos)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"LowParse.Low.Base.Spec.valid",
"Prims.Nil"
] | [] | true | false | true | false | false | let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] =
| valid_exact_valid p h s pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_frame | val valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] | val valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] | let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f () | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 30,
"end_line": 602,
"start_col": 0,
"start_line": 563
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h s /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l (LowParse.Slice.loc_slice_from_to s pos pos'))
(ensures
LowParse.Low.Base.Spec.valid_exact p h s pos pos' \/
LowParse.Low.Base.Spec.valid_exact p h' s pos pos' ==>
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.valid_exact p h' s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h' s pos pos' ==
LowParse.Low.Base.Spec.contents_exact p h s pos pos')
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h' s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents_exact p h s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents_exact p h' s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"LowParse.Low.Base.Spec.valid_exact'",
"LowParse.Low.Base.Spec.contents_exact'",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Slice.live_slice",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"Prims.l_imp",
"Prims.Cons",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat"
] | [] | false | false | true | false | false | let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] =
| let f ()
: Lemma
(requires
(U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')))
(ensures
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')) =
valid_exact_equiv p h s pos pos';
valid_exact_equiv p h' s pos pos';
Classical.move_requires (contents_exact_eq p h s pos) pos';
Classical.move_requires (contents_exact_eq p h' s pos) pos';
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f () | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_valid_exact_consumes_all | val valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len))) | val valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len))) | let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 61,
"end_line": 622,
"start_col": 0,
"start_line": 604
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserConsumesAll)
(ensures
LowParse.Low.Base.Spec.valid p h s pos \/
LowParse.Low.Base.Spec.valid_exact p h s pos (Mkslice?.len s) ==>
LowParse.Low.Base.Spec.valid_exact p h s pos (Mkslice?.len s) /\
LowParse.Low.Base.Spec.valid_content_pos p
h
s
pos
(LowParse.Low.Base.Spec.contents_exact p h s pos (Mkslice?.len s))
(Mkslice?.len s)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents_exact'",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserConsumesAll",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.valid_content_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len))) =
| parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos_valid_exact | val valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)) | val valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)) | let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 663,
"start_col": 0,
"start_line": 648
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos') | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_pos p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h s pos pos' ==
LowParse.Low.Base.Spec.contents p h s pos) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_valid_exact",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)) =
| valid_valid_exact p h s pos | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_compose_strong | val clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3) | val clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3) | let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
} | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1152,
"start_col": 0,
"start_line": 1142
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
l12: LowParse.Low.Base.Spec.clens t1 t2 ->
l23:
LowParse.Low.Base.Spec.clens t2 t3 {LowParse.Low.Base.Spec.clens_compose_strong_pre l12 l23}
-> LowParse.Low.Base.Spec.clens t1 t3 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.clens_compose_strong_pre",
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | false | false | false | false | false | let clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3) =
| { clens_cond = l12.clens_cond; clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1)) } | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos_frame_strong_1 | val valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')) | val valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')) | let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 36,
"end_line": 739,
"start_col": 0,
"start_line": 719
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos') l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
pos') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')) =
| valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_ext_elim | val valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | val valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 58,
"end_line": 937,
"start_col": 0,
"start_line": 908
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h1 s1 pos1 /\ LowParse.Low.Base.Spec.valid p h2 s2 pos2 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.contents p h1 s1 pos1 == LowParse.Low.Base.Spec.contents p h2 s2 pos2
)
(ensures
(let pos1' = LowParse.Low.Base.Spec.get_valid_pos p h1 s1 pos1 in
let pos2' = LowParse.Low.Base.Spec.get_valid_pos p h2 s2 pos2 in
FStar.UInt32.v pos2' - FStar.UInt32.v pos2 == FStar.UInt32.v pos1' - FStar.UInt32.v pos1 /\
LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1' ==
LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_ext_elim",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_valid_exact",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.contents",
"Prims.squash",
"Prims.int",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) =
| let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_frame_strong | val valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | val valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 67,
"end_line": 812,
"start_col": 0,
"start_line": 788
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowParse.Low.Base.Spec.valid p h sl pos /\
LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl
pos
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos))
l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos))
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.content_length p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.valid_pos_frame_strong",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.unit",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat",
"Prims.Nil",
"Prims.nat",
"LowParse.Low.Base.Spec.content_length"
] | [] | true | false | true | false | false | let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] =
| valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.serialize_valid_exact | val serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x)) | val serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x)) | let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 35,
"end_line": 561,
"start_col": 0,
"start_line": 537
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
x: t ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\
FStar.UInt32.v pos + FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) ==
FStar.UInt32.v pos' /\ FStar.UInt32.v pos' <= FStar.UInt32.v (Mkslice?.len sl) /\
FStar.Seq.Base.equal (LowParse.Low.Base.Spec.bytes_of_slice_from_to h sl pos pos')
(LowParse.Spec.Base.serialize s x))
(ensures
LowParse.Low.Base.Spec.valid_exact p h sl pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h sl pos pos' == x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_exact_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Spec.Base.serializer_correct_implies_complete",
"Prims.l_and",
"LowParse.Slice.live_slice",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"FStar.Seq.Base.equal",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x)) =
| serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos';
contents_exact_eq p h sl pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_frame | val valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | val valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f () | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 30,
"end_line": 386,
"start_col": 0,
"start_line": 350
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from sl pos) l)
(ensures
LowParse.Low.Base.Spec.valid p h sl pos \/ LowParse.Low.Base.Spec.valid p h' sl pos ==>
LowParse.Low.Base.Spec.valid p h sl pos /\
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos))
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid p h sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.valid p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents p h sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.content_length p h sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.content_length p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Low.Base.Spec.valid_facts",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"LowParse.Slice.live_slice",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from",
"Prims.l_imp",
"Prims.Cons",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat",
"Prims.nat",
"LowParse.Low.Base.Spec.content_length"
] | [] | false | false | true | false | false | let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] =
| let f ()
: Lemma (requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))) =
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f () | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_compose | val clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3) | val clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3) | let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
} | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1131,
"start_col": 0,
"start_line": 1111
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | l12: LowParse.Low.Base.Spec.clens t1 t2 -> l23: LowParse.Low.Base.Spec.clens t2 t3
-> LowParse.Low.Base.Spec.clens t1 t3 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Low.Base.Spec.clens_compose_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | false | false | false | true | false | let clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3) =
| {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1))
} | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_eq | val clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0 | val clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0 | let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x)) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 149,
"end_line": 961,
"start_col": 0,
"start_line": 959
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 | cl1: LowParse.Low.Base.Spec.clens t t' -> cl2: LowParse.Low.Base.Spec.clens t t' -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_iff",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.l_imp",
"Prims.l_or",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | false | false | false | false | true | let clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0 =
| (forall (x: t). {:pattern (cl1.clens_cond x)\/(cl2.clens_cond x)}
cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t). {:pattern (cl1.clens_get x)\/(cl2.clens_get x)}
(cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x)) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_no_lookahead_weaken | val gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl')) | val gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl')) | let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 1270,
"start_col": 0,
"start_line": 1253
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre p1 p2 cl sl /\
LowParse.Spec.Base.no_lookahead_on_precond p1 sl sl')
(ensures LowParse.Low.Base.Spec.gaccessor_pre p1 p2 cl sl') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_strong_prefix",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl')) =
| parse_strong_prefix p1 sl sl' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_ext_elim | val valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | val valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2')) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 115,
"end_line": 875,
"start_col": 0,
"start_line": 845
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
pos1': FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t ->
pos2': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h1 s1 pos1 pos1' /\
LowParse.Low.Base.Spec.valid_exact p h2 s2 pos2 pos2' /\
LowParse.Low.Base.Spec.contents_exact p h1 s1 pos1 pos1' ==
LowParse.Low.Base.Spec.contents_exact p h2 s2 pos2 pos2')
(ensures
FStar.UInt32.v pos2' - FStar.UInt32.v pos2 == FStar.UInt32.v pos1' - FStar.UInt32.v pos1 /\
LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1' ==
LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims._assert",
"LowParse.Spec.Base.injective_postcond",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.unit",
"LowParse.Spec.Base.injective_precond",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.squash",
"Prims.int",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) =
| valid_exact_equiv p h1 s1 pos1 pos1';
valid_exact_equiv p h2 s2 pos2 pos2';
contents_exact_eq p h1 s1 pos1 pos1';
contents_exact_eq p h2 s2 pos2 pos2';
parser_kind_prop_equiv k p;
assert (injective_precond p
(bytes_of_slice_from_to h1 s1 pos1 pos1')
(bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p
(bytes_of_slice_from_to h1 s1 pos1 pos1')
(bytes_of_slice_from_to h2 s2 pos2 pos2')) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_eq_intro' | val clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2)) | val clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2)) | let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ()) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 62,
"end_line": 993,
"start_col": 0,
"start_line": 981
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
cl1: LowParse.Low.Base.Spec.clens t t' ->
cl2: LowParse.Low.Base.Spec.clens t t' ->
cond: (x: t -> Prims.squash (Mkclens?.clens_cond cl1 x <==> Mkclens?.clens_cond cl2 x)) ->
get:
(x: t -> sq: Prims.squash (Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x)
-> Prims.squash (Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x /\
Mkclens?.clens_get cl1 x == Mkclens?.clens_get cl2 x))
-> Prims.squash (LowParse.Low.Base.Spec.clens_eq cl1 cl2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"Prims.squash",
"Prims.l_iff",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.l_and",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"LowParse.Low.Base.Spec.clens_eq_intro",
"Prims.unit",
"LowParse.Low.Base.Spec.clens_eq"
] | [] | false | false | true | false | false | let clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2)) =
| clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ()) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_post | val gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | val gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1209,
"start_col": 0,
"start_line": 1187
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
cl: LowParse.Low.Base.Spec.clens t1 t2 ->
sl: LowParse.Bytes.bytes ->
res: Prims.nat
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"FStar.Seq.Base.slice",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"Prims.op_Addition",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.l_False",
"Prims.logical"
] | [] | false | false | false | false | true | let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 =
| res <= Seq.length sl /\
(match parse p1 sl with
| Some (x1, consumed1) ->
(match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\ x2 == cl.clens_get x1 /\ res + consumed2 <= consumed1
| _ -> False)
| _ -> False) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_pos_frame_strong_2 | val valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos')) | val valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos')) | let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 35,
"end_line": 763,
"start_col": 0,
"start_line": 741
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowParse.Low.Base.Spec.valid_pos p h' sl pos pos' /\
LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos') l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\
LowParse.Low.Base.Spec.valid_pos p h' sl pos pos' /\
LowParse.Low.Base.Spec.valid_content_pos p
h
sl
pos
(LowParse.Low.Base.Spec.contents p h' sl pos)
pos') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Low.Base.Spec.valid_pos",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos')) =
| valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.clens_eq_intro | val clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2) | val clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2) | let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get) | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 54,
"end_line": 979,
"start_col": 0,
"start_line": 963
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
cl1: LowParse.Low.Base.Spec.clens t t' ->
cl2: LowParse.Low.Base.Spec.clens t t' ->
cond:
(x: t
-> FStar.Pervasives.Lemma
(ensures Mkclens?.clens_cond cl1 x <==> Mkclens?.clens_cond cl2 x)) ->
get:
(x: t
-> FStar.Pervasives.Lemma
(requires Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x)
(ensures
Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x /\
Mkclens?.clens_get cl1 x == Mkclens?.clens_get cl2 x))
-> FStar.Pervasives.Lemma (ensures LowParse.Low.Base.Spec.clens_eq cl1 cl2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Low.Base.Spec.clens",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.l_and",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.clens_eq"
] | [] | false | false | true | false | false | let clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2) =
| Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get) | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_exact_ext_intro | val valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1')) | val valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1')) | let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 843,
"start_col": 0,
"start_line": 814
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
pos1': FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t ->
pos2': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h1 s1 pos1 pos1' /\ LowParse.Slice.live_slice h2 s2 /\
FStar.UInt32.v pos1' - FStar.UInt32.v pos1 == FStar.UInt32.v pos2' - FStar.UInt32.v pos2 /\
FStar.UInt32.v pos2' <= FStar.UInt32.v (Mkslice?.len s2) /\
FStar.Seq.Base.equal (LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1')
(LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2'))
(ensures
LowParse.Low.Base.Spec.valid_exact p h2 s2 pos2 pos2' /\
LowParse.Low.Base.Spec.contents_exact p h2 s2 pos2 pos2' ==
LowParse.Low.Base.Spec.contents_exact p h1 s1 pos1 pos1') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_exact_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Slice.live_slice",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"FStar.Seq.Base.equal",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.squash",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1')) =
| valid_exact_equiv p h1 s1 pos1 pos1';
valid_exact_equiv p h2 s2 pos2 pos2';
contents_exact_eq p h1 s1 pos1 pos1';
contents_exact_eq p h2 s2 pos2 pos2' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_valid_exact | val valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))) | val valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))) | let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos') | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 91,
"end_line": 646,
"start_col": 0,
"start_line": 624
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h s pos /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
(let npos' = FStar.UInt32.v pos + LowParse.Low.Base.Spec.content_length p h s pos in
npos' <= FStar.UInt32.v (Mkslice?.len s) /\
(let pos' = FStar.UInt32.uint_to_t npos' in
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h s pos pos' ==
LowParse.Low.Base.Spec.contents p h s pos))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.unit",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents_exact'",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"FStar.UInt32.uint_to_t",
"Prims.int",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.valid",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.squash",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))) =
| valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos';
Classical.move_requires (contents_exact_eq p h s pos) pos';
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos') | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.valid_ext_intro | val valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1)))) | val valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1)))) | let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 906,
"start_col": 0,
"start_line": 877
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h1 s1 pos1 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
(let pos1' = LowParse.Low.Base.Spec.get_valid_pos p h1 s1 pos1 in
LowParse.Slice.live_slice h2 s2 /\
FStar.UInt32.v pos2 + (FStar.UInt32.v pos1' - FStar.UInt32.v pos1) <=
FStar.UInt32.v (Mkslice?.len s2) /\
(let pos2' = FStar.UInt32.add pos2 (FStar.UInt32.sub pos1' pos1) in
FStar.Seq.Base.equal (LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1')
(LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2'))))
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h2
s2
pos2
(LowParse.Low.Base.Spec.contents p h1 s1 pos1)
(FStar.UInt32.add pos2
(FStar.UInt32.sub (LowParse.Low.Base.Spec.get_valid_pos p h1 s1 pos1) pos1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_ext_intro",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"FStar.UInt32.add",
"FStar.UInt32.sub",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Slice.live_slice",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"Prims.op_Subtraction",
"LowParse.Slice.__proj__Mkslice__item__len",
"FStar.Seq.Base.equal",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1)))) =
| let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1';
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2';
valid_exact_valid p h2 s2 pos2 pos2' | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_id' | val gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res)) | val gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res)) | let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0 | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1486,
"start_col": 0,
"start_line": 1478
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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: LowParse.Spec.Base.parser k t -> input: LowParse.Bytes.bytes -> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Low.Base.Spec.clens_id"
] | [] | false | false | false | false | false | let gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res)) =
| 0 | false |
LowParse.Low.Base.Spec.fsti | LowParse.Low.Base.Spec.gaccessor_ext' | val gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res)) | val gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res)) | let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 9,
"end_line": 1515,
"start_col": 0,
"start_line": 1502
} | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "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 |
g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl ->
cl': LowParse.Low.Base.Spec.clens t1 t2 ->
sq: Prims.squash (LowParse.Low.Base.Spec.clens_eq cl cl') ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"Prims.squash",
"LowParse.Low.Base.Spec.clens_eq",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'"
] | [] | false | false | false | false | false | let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res)) =
| g input | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.