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.UInt.fsti | FStar.UInt.to_uint_t | val to_uint_t (m: nat) (a: int) : Tot (uint_t m) | val to_uint_t (m: nat) (a: int) : Tot (uint_t m) | let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 173,
"start_col": 0,
"start_line": 173
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | m: Prims.nat -> a: Prims.int -> FStar.UInt.uint_t m | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.int",
"Prims.op_Modulus",
"Prims.pow2",
"FStar.UInt.uint_t"
] | [] | false | false | false | false | false | let to_uint_t (m: nat) (a: int) : Tot (uint_t m) =
| a % pow2 m | false |
FStar.UInt.fsti | FStar.UInt.nth | val nth (#n: pos) (a: uint_t n) (i: nat{i < n}) : Tot bool | val nth (#n: pos) (a: uint_t n) (i: nat{i < n}) : Tot bool | let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 270,
"start_col": 0,
"start_line": 269
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> i: Prims.nat{i < n} -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Prims.bool",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let nth (#n: pos) (a: uint_t n) (i: nat{i < n}) : Tot bool =
| index (to_vec #n a) i | false |
FStar.UInt.fsti | FStar.UInt.to_vec | val to_vec (#n: nat) (num: uint_t n) : Tot (bv_t n) | val to_vec (#n: nat) (num: uint_t n) : Tot (bv_t n) | let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 182,
"start_col": 0,
"start_line": 180
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | num: FStar.UInt.uint_t n -> FStar.BitVector.bv_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.UInt.uint_t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.UInt.to_vec",
"Prims.op_Subtraction",
"Prims.op_Division",
"FStar.Seq.Base.create",
"Prims.op_Modulus",
"FStar.BitVector.bv_t"
] | [
"recursion"
] | false | false | false | false | false | let rec to_vec (#n: nat) (num: uint_t n) : Tot (bv_t n) =
| if n = 0
then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1)) | false |
FStar.UInt.fsti | FStar.UInt.msb | val msb (#n: pos) (a: uint_t n) : Tot bool | val msb (#n: pos) (a: uint_t n) : Tot bool | let msb (#n:pos) (a:uint_t n) : Tot bool = nth a 0 | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 537,
"start_col": 0,
"start_line": 537
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *)
let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s)
let shift_right (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_right_vec #n (to_vec #n a) s)
(* Shift operators lemmas *)
val shift_left_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = false))
[SMTPat (nth (shift_left #n a s) i)]
val shift_left_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = nth #n a (i + s)))
[SMTPat (nth (shift_left #n a s) i)]
val shift_right_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = false))
[SMTPat (nth (shift_right #n a s) i)]
val shift_right_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = nth #n a (i - s)))
[SMTPat (nth (shift_right #n a s) i)]
(* Lemmas with shift operators and bitwise operators *)
val shift_left_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logand #n a b) s = logand #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logand #n a b) s = logand #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logxor #n a b) s = logxor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logxor #n a b) s = logxor #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logor #n a b) s = logor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logor #n a b) s = logor #n (shift_right #n a s) (shift_right #n b s)))
(* Lemmas about value after shift operations *)
val shift_left_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_left #n a 0 = (a * pow2 0) % pow2 n)
val shift_left_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
[SMTPat (shift_left #n a s)]
val shift_right_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_right #n a 0 = a / pow2 0)
val shift_right_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
[SMTPat (shift_right #n a s)]
(* Lemmas about the most significant bit in various situations *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.nth",
"Prims.bool"
] | [] | false | false | false | false | false | let msb (#n: pos) (a: uint_t n) : Tot bool =
| nth a 0 | false |
FStar.UInt.fsti | FStar.UInt.minus | val minus (#n: pos) (a: uint_t n) : Tot (uint_t n) | val minus (#n: pos) (a: uint_t n) : Tot (uint_t n) | let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1 | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 334,
"start_col": 0,
"start_line": 333
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.add_mod",
"FStar.UInt.lognot"
] | [] | false | false | false | false | false | let minus (#n: pos) (a: uint_t n) : Tot (uint_t n) =
| add_mod (lognot a) 1 | false |
FStar.UInt.fsti | FStar.UInt.lognot | val lognot (#n: pos) (a: uint_t n) : Tot (uint_t n) | val lognot (#n: pos) (a: uint_t n) : Tot (uint_t n) | let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 308,
"start_col": 0,
"start_line": 307
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.from_vec",
"FStar.BitVector.lognot_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let lognot (#n: pos) (a: uint_t n) : Tot (uint_t n) =
| from_vec #n (lognot_vec #n (to_vec #n a)) | false |
FStar.UInt.fsti | FStar.UInt.zero_extend_vec | val zero_extend_vec (#n: pos) (a: BitVector.bv_t n) : Tot (BitVector.bv_t (n + 1)) | val zero_extend_vec (#n: pos) (a: BitVector.bv_t n) : Tot (BitVector.bv_t (n + 1)) | let zero_extend_vec (#n:pos) (a:BitVector.bv_t n): Tot (BitVector.bv_t (n+1)) = Seq.append (Seq.create 1 false) a | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 113,
"end_line": 563,
"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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *)
let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s)
let shift_right (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_right_vec #n (to_vec #n a) s)
(* Shift operators lemmas *)
val shift_left_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = false))
[SMTPat (nth (shift_left #n a s) i)]
val shift_left_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = nth #n a (i + s)))
[SMTPat (nth (shift_left #n a s) i)]
val shift_right_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = false))
[SMTPat (nth (shift_right #n a s) i)]
val shift_right_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = nth #n a (i - s)))
[SMTPat (nth (shift_right #n a s) i)]
(* Lemmas with shift operators and bitwise operators *)
val shift_left_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logand #n a b) s = logand #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logand #n a b) s = logand #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logxor #n a b) s = logxor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logxor #n a b) s = logxor #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logor #n a b) s = logor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logor #n a b) s = logor #n (shift_right #n a s) (shift_right #n b s)))
(* Lemmas about value after shift operations *)
val shift_left_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_left #n a 0 = (a * pow2 0) % pow2 n)
val shift_left_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
[SMTPat (shift_left #n a s)]
val shift_right_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_right #n a 0 = a / pow2 0)
val shift_right_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
[SMTPat (shift_right #n a s)]
(* Lemmas about the most significant bit in various situations *)
let msb (#n:pos) (a:uint_t n) : Tot bool = nth a 0
val lemma_msb_pow2: #n:pos -> a:uint_t n ->
Lemma (msb a <==> a >= pow2 (n-1))
val lemma_minus_zero: #n:pos -> a:uint_t n ->
Lemma (minus a = 0 ==> a = 0)
val lemma_msb_gte: #n:pos{n > 1} -> a:uint_t n -> b:uint_t n ->
Lemma ((a >= b && not (msb a)) ==> not (msb b))
(* Lemmas toward showing ~n + 1 = -a *)
val lemma_uint_mod: #n:pos -> a:uint_t n ->
Lemma (a = a % pow2 n)
val lemma_add_sub_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (add_mod (sub_mod a b) b = a)
val lemma_mod_sub_distr_l: a:int -> b:int -> p:pos ->
Lemma ((a - b) % p = ((a % p) - b) % p)
val lemma_sub_add_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (sub_mod (add_mod a b) b = a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.BitVector.bv_t n -> FStar.BitVector.bv_t (n + 1) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.BitVector.bv_t",
"FStar.Seq.Base.append",
"Prims.bool",
"FStar.Seq.Base.create",
"Prims.op_Addition"
] | [] | false | false | false | false | false | let zero_extend_vec (#n: pos) (a: BitVector.bv_t n) : Tot (BitVector.bv_t (n + 1)) =
| Seq.append (Seq.create 1 false) a | false |
FStar.UInt.fsti | FStar.UInt.logand | val logand (#n: pos) (a b: uint_t n) : Tot (uint_t n) | val logand (#n: pos) (a b: uint_t n) : Tot (uint_t n) | let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 299,
"start_col": 0,
"start_line": 298
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> b: FStar.UInt.uint_t n -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.from_vec",
"FStar.BitVector.logand_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let logand (#n: pos) (a b: uint_t n) : Tot (uint_t n) =
| from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b)) | false |
FStar.UInt.fsti | FStar.UInt.one_extend_vec | val one_extend_vec (#n: pos) (a: BitVector.bv_t n) : Tot (BitVector.bv_t (n + 1)) | val one_extend_vec (#n: pos) (a: BitVector.bv_t n) : Tot (BitVector.bv_t (n + 1)) | let one_extend_vec (#n:pos) (a:BitVector.bv_t n): Tot (BitVector.bv_t (n+1)) = Seq.append (Seq.create 1 true) a | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 111,
"end_line": 564,
"start_col": 0,
"start_line": 564
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *)
let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s)
let shift_right (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_right_vec #n (to_vec #n a) s)
(* Shift operators lemmas *)
val shift_left_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = false))
[SMTPat (nth (shift_left #n a s) i)]
val shift_left_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = nth #n a (i + s)))
[SMTPat (nth (shift_left #n a s) i)]
val shift_right_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = false))
[SMTPat (nth (shift_right #n a s) i)]
val shift_right_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = nth #n a (i - s)))
[SMTPat (nth (shift_right #n a s) i)]
(* Lemmas with shift operators and bitwise operators *)
val shift_left_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logand #n a b) s = logand #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logand #n a b) s = logand #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logxor #n a b) s = logxor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logxor #n a b) s = logxor #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logor #n a b) s = logor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logor #n a b) s = logor #n (shift_right #n a s) (shift_right #n b s)))
(* Lemmas about value after shift operations *)
val shift_left_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_left #n a 0 = (a * pow2 0) % pow2 n)
val shift_left_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
[SMTPat (shift_left #n a s)]
val shift_right_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_right #n a 0 = a / pow2 0)
val shift_right_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
[SMTPat (shift_right #n a s)]
(* Lemmas about the most significant bit in various situations *)
let msb (#n:pos) (a:uint_t n) : Tot bool = nth a 0
val lemma_msb_pow2: #n:pos -> a:uint_t n ->
Lemma (msb a <==> a >= pow2 (n-1))
val lemma_minus_zero: #n:pos -> a:uint_t n ->
Lemma (minus a = 0 ==> a = 0)
val lemma_msb_gte: #n:pos{n > 1} -> a:uint_t n -> b:uint_t n ->
Lemma ((a >= b && not (msb a)) ==> not (msb b))
(* Lemmas toward showing ~n + 1 = -a *)
val lemma_uint_mod: #n:pos -> a:uint_t n ->
Lemma (a = a % pow2 n)
val lemma_add_sub_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (add_mod (sub_mod a b) b = a)
val lemma_mod_sub_distr_l: a:int -> b:int -> p:pos ->
Lemma ((a - b) % p = ((a % p) - b) % p)
val lemma_sub_add_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (sub_mod (add_mod a b) b = a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.BitVector.bv_t n -> FStar.BitVector.bv_t (n + 1) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.BitVector.bv_t",
"FStar.Seq.Base.append",
"Prims.bool",
"FStar.Seq.Base.create",
"Prims.op_Addition"
] | [] | false | false | false | false | false | let one_extend_vec (#n: pos) (a: BitVector.bv_t n) : Tot (BitVector.bv_t (n + 1)) =
| Seq.append (Seq.create 1 true) a | false |
FStar.UInt.fsti | FStar.UInt.logxor | val logxor (#n: pos) (a b: uint_t n) : Tot (uint_t n) | val logxor (#n: pos) (a b: uint_t n) : Tot (uint_t n) | let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 302,
"start_col": 0,
"start_line": 301
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> b: FStar.UInt.uint_t n -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.from_vec",
"FStar.BitVector.logxor_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let logxor (#n: pos) (a b: uint_t n) : Tot (uint_t n) =
| from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b)) | false |
FStar.UInt.fsti | FStar.UInt.zero_extend | val zero_extend (#n: pos) (a: uint_t n) : Tot (uint_t (n + 1)) | val zero_extend (#n: pos) (a: uint_t n) : Tot (uint_t (n + 1)) | let zero_extend (#n:pos) (a:uint_t n): Tot (uint_t (n+1)) = from_vec (zero_extend_vec (to_vec a)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 566,
"start_col": 0,
"start_line": 566
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *)
let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s)
let shift_right (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_right_vec #n (to_vec #n a) s)
(* Shift operators lemmas *)
val shift_left_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = false))
[SMTPat (nth (shift_left #n a s) i)]
val shift_left_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = nth #n a (i + s)))
[SMTPat (nth (shift_left #n a s) i)]
val shift_right_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = false))
[SMTPat (nth (shift_right #n a s) i)]
val shift_right_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = nth #n a (i - s)))
[SMTPat (nth (shift_right #n a s) i)]
(* Lemmas with shift operators and bitwise operators *)
val shift_left_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logand #n a b) s = logand #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logand #n a b) s = logand #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logxor #n a b) s = logxor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logxor #n a b) s = logxor #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logor #n a b) s = logor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logor #n a b) s = logor #n (shift_right #n a s) (shift_right #n b s)))
(* Lemmas about value after shift operations *)
val shift_left_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_left #n a 0 = (a * pow2 0) % pow2 n)
val shift_left_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
[SMTPat (shift_left #n a s)]
val shift_right_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_right #n a 0 = a / pow2 0)
val shift_right_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
[SMTPat (shift_right #n a s)]
(* Lemmas about the most significant bit in various situations *)
let msb (#n:pos) (a:uint_t n) : Tot bool = nth a 0
val lemma_msb_pow2: #n:pos -> a:uint_t n ->
Lemma (msb a <==> a >= pow2 (n-1))
val lemma_minus_zero: #n:pos -> a:uint_t n ->
Lemma (minus a = 0 ==> a = 0)
val lemma_msb_gte: #n:pos{n > 1} -> a:uint_t n -> b:uint_t n ->
Lemma ((a >= b && not (msb a)) ==> not (msb b))
(* Lemmas toward showing ~n + 1 = -a *)
val lemma_uint_mod: #n:pos -> a:uint_t n ->
Lemma (a = a % pow2 n)
val lemma_add_sub_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (add_mod (sub_mod a b) b = a)
val lemma_mod_sub_distr_l: a:int -> b:int -> p:pos ->
Lemma ((a - b) % p = ((a % p) - b) % p)
val lemma_sub_add_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (sub_mod (add_mod a b) b = a)
let zero_extend_vec (#n:pos) (a:BitVector.bv_t n): Tot (BitVector.bv_t (n+1)) = Seq.append (Seq.create 1 false) a
let one_extend_vec (#n:pos) (a:BitVector.bv_t n): Tot (BitVector.bv_t (n+1)) = Seq.append (Seq.create 1 true) a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> FStar.UInt.uint_t (n + 1) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.from_vec",
"Prims.op_Addition",
"FStar.UInt.zero_extend_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let zero_extend (#n: pos) (a: uint_t n) : Tot (uint_t (n + 1)) =
| from_vec (zero_extend_vec (to_vec a)) | false |
FStar.UInt.fsti | FStar.UInt.shift_left | val shift_left (#n: pos) (a: uint_t n) (s: nat) : Tot (uint_t n) | val shift_left (#n: pos) (a: uint_t n) (s: nat) : Tot (uint_t n) | let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 448,
"start_col": 0,
"start_line": 447
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> s: Prims.nat -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"FStar.UInt.from_vec",
"FStar.BitVector.shift_left_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let shift_left (#n: pos) (a: uint_t n) (s: nat) : Tot (uint_t n) =
| from_vec (shift_left_vec #n (to_vec #n a) s) | false |
FStar.UInt.fsti | FStar.UInt.logor | val logor (#n: pos) (a b: uint_t n) : Tot (uint_t n) | val logor (#n: pos) (a b: uint_t n) : Tot (uint_t n) | let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 305,
"start_col": 0,
"start_line": 304
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> b: FStar.UInt.uint_t n -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.from_vec",
"FStar.BitVector.logor_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let logor (#n: pos) (a b: uint_t n) : Tot (uint_t n) =
| from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b)) | false |
FStar.UInt.fsti | FStar.UInt.one_extend | val one_extend (#n: pos) (a: uint_t n) : Tot (uint_t (n + 1)) | val one_extend (#n: pos) (a: uint_t n) : Tot (uint_t (n + 1)) | let one_extend (#n:pos) (a:uint_t n): Tot (uint_t (n+1)) = from_vec (one_extend_vec (to_vec a)) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 95,
"end_line": 567,
"start_col": 0,
"start_line": 567
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *)
let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s)
let shift_right (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_right_vec #n (to_vec #n a) s)
(* Shift operators lemmas *)
val shift_left_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = false))
[SMTPat (nth (shift_left #n a s) i)]
val shift_left_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < n - s} ->
Lemma (requires True)
(ensures (nth (shift_left #n a s) i = nth #n a (i + s)))
[SMTPat (nth (shift_left #n a s) i)]
val shift_right_lemma_1: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i < s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = false))
[SMTPat (nth (shift_right #n a s) i)]
val shift_right_lemma_2: #n:pos -> a:uint_t n -> s:nat -> i:nat{i < n && i >= s} ->
Lemma (requires True)
(ensures (nth (shift_right #n a s) i = nth #n a (i - s)))
[SMTPat (nth (shift_right #n a s) i)]
(* Lemmas with shift operators and bitwise operators *)
val shift_left_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logand #n a b) s = logand #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logand_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logand #n a b) s = logand #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logxor #n a b) s = logxor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logxor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logxor #n a b) s = logxor #n (shift_right #n a s) (shift_right #n b s)))
val shift_left_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_left #n (logor #n a b) s = logor #n (shift_left #n a s) (shift_left #n b s)))
val shift_right_logor_lemma: #n:pos -> a:uint_t n -> b:uint_t n -> s:nat ->
Lemma (requires True)
(ensures (shift_right #n (logor #n a b) s = logor #n (shift_right #n a s) (shift_right #n b s)))
(* Lemmas about value after shift operations *)
val shift_left_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_left #n a 0 = (a * pow2 0) % pow2 n)
val shift_left_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
val shift_left_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_left #n a s = (a * pow2 s) % pow2 n)
[SMTPat (shift_left #n a s)]
val shift_right_value_aux_1: #n:pos -> a:uint_t n -> s:nat{s >= n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_aux_2: #n:pos -> a:uint_t n ->
Lemma (requires True)
(ensures shift_right #n a 0 = a / pow2 0)
val shift_right_value_aux_3: #n:pos -> a:uint_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
val shift_right_value_lemma: #n:pos -> a:uint_t n -> s:nat ->
Lemma (requires True)
(ensures shift_right #n a s = a / pow2 s)
[SMTPat (shift_right #n a s)]
(* Lemmas about the most significant bit in various situations *)
let msb (#n:pos) (a:uint_t n) : Tot bool = nth a 0
val lemma_msb_pow2: #n:pos -> a:uint_t n ->
Lemma (msb a <==> a >= pow2 (n-1))
val lemma_minus_zero: #n:pos -> a:uint_t n ->
Lemma (minus a = 0 ==> a = 0)
val lemma_msb_gte: #n:pos{n > 1} -> a:uint_t n -> b:uint_t n ->
Lemma ((a >= b && not (msb a)) ==> not (msb b))
(* Lemmas toward showing ~n + 1 = -a *)
val lemma_uint_mod: #n:pos -> a:uint_t n ->
Lemma (a = a % pow2 n)
val lemma_add_sub_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (add_mod (sub_mod a b) b = a)
val lemma_mod_sub_distr_l: a:int -> b:int -> p:pos ->
Lemma ((a - b) % p = ((a % p) - b) % p)
val lemma_sub_add_cancel: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (sub_mod (add_mod a b) b = a)
let zero_extend_vec (#n:pos) (a:BitVector.bv_t n): Tot (BitVector.bv_t (n+1)) = Seq.append (Seq.create 1 false) a
let one_extend_vec (#n:pos) (a:BitVector.bv_t n): Tot (BitVector.bv_t (n+1)) = Seq.append (Seq.create 1 true) a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> FStar.UInt.uint_t (n + 1) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.UInt.from_vec",
"Prims.op_Addition",
"FStar.UInt.one_extend_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let one_extend (#n: pos) (a: uint_t n) : Tot (uint_t (n + 1)) =
| from_vec (one_extend_vec (to_vec a)) | false |
FStar.UInt.fsti | FStar.UInt.shift_right | val shift_right (#n: pos) (a: uint_t n) (s: nat) : Tot (uint_t n) | val shift_right (#n: pos) (a: uint_t n) (s: nat) : Tot (uint_t n) | let shift_right (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_right_vec #n (to_vec #n a) s) | {
"file_name": "ulib/FStar.UInt.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 451,
"start_col": 0,
"start_line": 450
} | (*
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.UInt
(* NOTE: anything that you fix/update here should be reflected in [FStar.Int.fsti], which is mostly
* a copy-paste of this module. *)
open FStar.Mul
open FStar.BitVector
open FStar.Math.Lemmas
val pow2_values: x:nat -> Lemma
(let p = pow2 x in
match x with
| 0 -> p=1
| 1 -> p=2
| 8 -> p=256
| 16 -> p=65536
| 31 -> p=2147483648
| 32 -> p=4294967296
| 63 -> p=9223372036854775808
| 64 -> p=18446744073709551616
| 128 -> p=0x100000000000000000000000000000000
| _ -> True)
[SMTPat (pow2 x)]
/// Specs
///
/// Note: lacking any type of functors for F*, this is a copy/paste of [FStar.Int.fst], where the relevant bits that changed are:
/// - definition of max and min
/// - use of regular integer modulus instead of wrap-around modulus
let max_int (n:nat) : Tot int = pow2 n - 1
let min_int (n:nat) : Tot int = 0
let fits (x:int) (n:nat) : Tot bool = min_int n <= x && x <= max_int n
let size (x:int) (n:nat) : Tot Type0 = b2t(fits x n)
(* Machine integer type *)
type uint_t (n:nat) = x:int{size x n}
/// Constants
let zero (n:nat) : Tot (uint_t n) = 0
let pow2_n (#n:pos) (p:nat{p < n}) : Tot (uint_t n) =
pow2_le_compat (n - 1) p; pow2 p
let one (n:pos) : Tot (uint_t n) = 1
let ones (n:nat) : Tot (uint_t n) = max_int n
(* Increment and decrement *)
let incr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a < max_int n))) (ensures (fun _ -> True))
= a + 1
let decr (#n:nat) (a:uint_t n) : Pure (uint_t n)
(requires (b2t (a > min_int n))) (ensures (fun _ -> True))
= a - 1
val incr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a < max_int n)))
(ensures (fun b -> a + 1 = b))
val decr_underspec: #n:nat -> a:uint_t n -> Pure (uint_t n)
(requires (b2t (a > min_int n)))
(ensures (fun b -> a - 1 = b))
let incr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a + 1) % (pow2 n)
let decr_mod (#n:nat) (a:uint_t n) : Tot (uint_t n) = (a - 1) % (pow2 n)
(* Addition primitives *)
let add (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a + b) n))
(ensures (fun _ -> True))
= a + b
val add_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a + b) n ==> a + b = c))
let add_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a + b) % (pow2 n)
(* Subtraction primitives *)
let sub (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a - b) n))
(ensures (fun _ -> True))
= a - b
val sub_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a - b) n ==> a - b = c))
let sub_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a - b) % (pow2 n)
(* Multiplication primitives *)
let mul (#n:nat) (a:uint_t n) (b:uint_t n) : Pure (uint_t n)
(requires (size (a * b) n))
(ensures (fun _ -> True))
= a * b
val mul_underspec: #n:nat -> a:uint_t n -> b:uint_t n -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
size (a * b) n ==> a * b = c))
let mul_mod (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
(a * b) % (pow2 n)
private
val lt_square_div_lt (a:nat) (b:pos) : Lemma
(requires (a < b * b))
(ensures (a / b < b))
#push-options "--fuel 0 --ifuel 0"
let mul_div (#n:nat) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
FStar.Math.Lemmas.lemma_mult_lt_sqr a b (pow2 n);
lt_square_div_lt (a * b) (pow2 n);
(a * b) / (pow2 n)
#pop-options
(* Division primitives *)
let div (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Pure (uint_t n)
(requires (size (a / b) n))
(ensures (fun c -> b <> 0 ==> a / b = c))
= a / b
val div_underspec: #n:nat -> a:uint_t n -> b:uint_t n{b <> 0} -> Pure (uint_t n)
(requires True)
(ensures (fun c ->
(b <> 0 /\ size (a / b) n) ==> a / b = c))
val div_size: #n:pos -> a:uint_t n -> b:uint_t n{b <> 0} ->
Lemma (requires (size a n)) (ensures (size (a / b) n))
let udiv (#n:pos) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (c:uint_t n{b <> 0 ==> a / b = c}) =
div_size #n a b;
a / b
(* Modulo primitives *)
let mod (#n:nat) (a:uint_t n) (b:uint_t n{b <> 0}) : Tot (uint_t n) =
a - ((a/b) * b)
(* Comparison operators *)
let eq #n (a:uint_t n) (b:uint_t n) : Tot bool = (a = b)
let gt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a > b)
let gte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a >= b)
let lt #n (a:uint_t n) (b:uint_t n) : Tot bool = (a < b)
let lte #n (a:uint_t n) (b:uint_t n) : Tot bool = (a <= b)
/// Casts
let to_uint_t (m:nat) (a:int) : Tot (uint_t m) = a % pow2 m
open FStar.Seq
(* WARNING: Mind the big endian vs little endian definition *)
(* Casts *)
let rec to_vec (#n:nat) (num:uint_t n) : Tot (bv_t n) =
if n = 0 then Seq.empty #bool
else Seq.append (to_vec #(n - 1) (num / 2)) (Seq.create 1 (num % 2 = 1))
let rec from_vec (#n:nat) (vec:bv_t n) : Tot (uint_t n) =
if n = 0 then 0
else 2 * from_vec #(n - 1) (slice vec 0 (n - 1)) + (if index vec (n - 1) then 1 else 0)
val to_vec_lemma_1: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires a = b) (ensures equal (to_vec a) (to_vec b))
val to_vec_lemma_2: #n:nat -> a:uint_t n -> b:uint_t n ->
Lemma (requires equal (to_vec a) (to_vec b)) (ensures a = b)
val inverse_aux: #n:nat -> vec:bv_t n -> i:nat{i < n} ->
Lemma (requires True) (ensures index vec i = index (to_vec (from_vec vec)) i)
[SMTPat (index (to_vec (from_vec vec)) i)]
val inverse_vec_lemma: #n:nat -> vec:bv_t n ->
Lemma (requires True) (ensures equal vec (to_vec (from_vec vec)))
[SMTPat (to_vec (from_vec vec))]
val inverse_num_lemma: #n:nat -> num:uint_t n ->
Lemma (requires True) (ensures num = from_vec (to_vec num))
[SMTPat (from_vec (to_vec num))]
val from_vec_lemma_1: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires equal a b) (ensures from_vec a = from_vec b)
val from_vec_lemma_2: #n:nat -> a:bv_t n -> b:bv_t n ->
Lemma (requires from_vec a = from_vec b) (ensures equal a b)
val from_vec_aux: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> s2:nat{s2 < s1} ->
Lemma (requires True)
(ensures (from_vec #s2 (slice a 0 s2)) * pow2 (n - s2) + (from_vec #(s1 - s2) (slice a s2 s1)) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)) = ((from_vec #s2 (slice a 0 s2)) * pow2 (s1 - s2) + (from_vec #(s1 - s2) (slice a s2 s1))) * pow2 (n - s1) + (from_vec #(n - s1) (slice a s1 n)))
val seq_slice_lemma: #n:nat -> a:bv_t n -> s1:nat{s1 < n} -> t1:nat{t1 >= s1 && t1 <= n} -> s2:nat{s2 < t1 - s1} -> t2:nat{t2 >= s2 && t2 <= t1 - s1} ->
Lemma (equal (slice (slice a s1 t1) s2 t2) (slice a (s1 + s2) (s1 + t2)))
val from_vec_propriety: #n:pos -> a:bv_t n -> s:nat{s < n} ->
Lemma (requires True)
(ensures from_vec a = (from_vec #s (slice a 0 s)) * pow2 (n - s) + from_vec #(n - s) (slice a s n))
(decreases (n - s))
val append_lemma: #n:pos -> #m:pos -> a:bv_t n -> b:bv_t m ->
Lemma (from_vec #(n + m) (append a b) = (from_vec #n a) * pow2 m + (from_vec #m b))
val slice_left_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a 0 s) = (from_vec #n a) / (pow2 (n - s)))
val slice_right_lemma: #n:pos -> a:bv_t n -> s:pos{s < n} ->
Lemma (requires True)
(ensures from_vec #s (slice a (n - s) n) = (from_vec #n a) % (pow2 s))
(* Relations between constants in BitVector and in UInt. *)
val zero_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures index (to_vec (zero n)) i = index (zero_vec #n) i)
[SMTPat (index (to_vec (zero n)) i)]
val zero_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (zero_vec #n) = zero n)
[SMTPat (from_vec (zero_vec #n))]
val one_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (one n)) i = index (elem_vec #n (n - 1)) i)
[SMTPat (index (to_vec (one n)) i)]
val pow2_to_vec_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (pow2_n #n p)) i = index (elem_vec #n (n - p - 1)) i)
[SMTPat (index (to_vec (pow2_n #n p)) i)]
val pow2_from_vec_lemma: #n:pos -> p:nat{p < n} ->
Lemma (requires True) (ensures from_vec (elem_vec #n p) = pow2_n #n (n - p - 1))
[SMTPat (from_vec (elem_vec #n p))]
val ones_to_vec_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures index (to_vec (ones n)) i = index (ones_vec #n) i)
[SMTPat (index (to_vec (ones n)) i)]
val ones_from_vec_lemma: #n:pos ->
Lemma (requires True) (ensures from_vec (ones_vec #n) = ones n)
[SMTPat (from_vec (ones_vec #n))]
(* (nth a i) returns a boolean indicating the i-th bit of a. *)
let nth (#n:pos) (a:uint_t n) (i:nat{i < n}) : Tot bool =
index (to_vec #n a) i
val nth_lemma: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires forall (i:nat{i < n}). nth a i = nth b i)
(ensures a = b)
(* Lemmas for constants *)
val zero_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures nth (zero n) i = false)
[SMTPat (nth (zero n) i)]
val pow2_nth_lemma: #n:pos -> p:nat{p < n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - p - 1 ==> nth (pow2_n #n p) i = true) /\
(i <> n - p - 1 ==> nth (pow2_n #n p) i = false))
[SMTPat (nth (pow2_n #n p) i)]
val one_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True)
(ensures (i = n - 1 ==> nth (one n) i = true) /\
(i < n - 1 ==> nth (one n) i = false))
[SMTPat (nth (one n) i)]
val ones_nth_lemma: #n:pos -> i:nat{i < n} ->
Lemma (requires True) (ensures (nth (ones n) i) = true)
[SMTPat (nth (ones n) i)]
(* Bitwise operators *)
let logand (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logand_vec #n (to_vec #n a) (to_vec #n b))
let logxor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logxor_vec #n (to_vec #n a) (to_vec #n b))
let logor (#n:pos) (a:uint_t n) (b:uint_t n) : Tot (uint_t n) =
from_vec #n (logor_vec #n (to_vec #n a) (to_vec #n b))
let lognot (#n:pos) (a:uint_t n) : Tot (uint_t n) =
from_vec #n (lognot_vec #n (to_vec #n a))
(* Bitwise operators definitions *)
val logand_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logand a b) i = (nth a i && nth b i)))
[SMTPat (nth (logand a b) i)]
val logxor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logxor a b) i = (nth a i <> nth b i)))
[SMTPat (nth (logxor a b) i)]
val logor_definition: #n:pos -> a:uint_t n -> b:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (logor a b) i = (nth a i || nth b i)))
[SMTPat (nth (logor a b) i)]
val lognot_definition: #n:pos -> a:uint_t n -> i:nat{i < n} ->
Lemma (requires True)
(ensures (nth (lognot a) i = not(nth a i)))
[SMTPat (nth (lognot a) i)]
(* Two's complement unary minus *)
inline_for_extraction
let minus (#n:pos) (a:uint_t n) : Tot (uint_t n) =
add_mod (lognot a) 1
(* Bitwise operators lemmas *)
(* TODO: lemmas about the relations between different operators *)
(* Bitwise AND operator *)
val logand_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logand #n a b = logand #n b a))
val logand_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logand #n (logand #n a b) c = logand #n a (logand #n b c)))
val logand_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a a = a))
val logand_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (zero n) = zero n))
val logand_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logand #n a (ones n) = a))
(* subset_vec_le_lemma proves that a subset of bits is numerically smaller or equal. *)
val subset_vec_le_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_subset_vec #n a b) (ensures (from_vec a) <= (from_vec b))
(* logand_le proves the the result of AND is less than or equal to both arguments. *)
val logand_le: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logand a b) <= a /\ (logand a b) <= b)
(* Bitwise XOR operator *)
val logxor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logxor #n a b = logxor #n b a))
val logxor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True) (ensures (logxor #n (logxor #n a b) c = logxor #n a (logxor #n b c)))
val logxor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a a = zero n))
val logxor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (zero n) = a))
val logxor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logxor #n a (ones n) = lognot #n a))
private let xor (b:bool) (b':bool) : Tot bool = b <> b'
private val xor_lemma (a:bool) (b:bool) : Lemma
(requires (True))
(ensures (xor (xor a b) b = a))
[SMTPat (xor (xor a b) b)]
val logxor_inv: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a = logxor #n (logxor #n a b) b)
val logxor_neq_nonzero: #n:pos -> a:uint_t n -> b:uint_t n -> Lemma
(a <> b ==> logxor a b <> 0)
(* Bitwise OR operators *)
val logor_commutative: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True) (ensures (logor #n a b = logor #n b a))
val logor_associative: #n:pos -> a:uint_t n -> b:uint_t n -> c:uint_t n ->
Lemma (requires True)
(ensures (logor #n (logor #n a b) c = logor #n a (logor #n b c)))
val logor_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a a = a))
val logor_lemma_1: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (zero n) = a))
val logor_lemma_2: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (logor #n a (ones n) = ones n))
(* superset_vec_le_lemma proves that a superset of bits is numerically greater than or equal. *)
val superset_vec_ge_lemma: #n:pos -> a:bv_t n -> b:bv_t n ->
Lemma (requires is_superset_vec #n a b)
(ensures (from_vec a) >= (from_vec b))
(* logor_ge proves that the result of an OR is greater than or equal to both arguments. *)
val logor_ge: #n:pos -> a:uint_t n -> b:uint_t n ->
Lemma (requires True)
(ensures (logor a b) >= a /\ (logor a b) >= b)
(* Bitwise NOT operator *)
val lognot_self: #n:pos -> a:uint_t n ->
Lemma (requires True) (ensures (lognot #n (lognot #n a) = a))
val lognot_lemma_1: #n:pos ->
Lemma (requires True) (ensures (lognot #n (zero n) = ones n))
(** Used in the next two lemmas *)
private val index_to_vec_ones: #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> index (to_vec #n (pow2 m - 1)) i == false) /\
(n - m <= i ==> index (to_vec #n (pow2 m - 1)) i == true)))
[SMTPat (index (to_vec #n (pow2 m - 1)) i)]
val logor_disjoint: #n:pos -> a:uint_t n -> b:uint_t n -> m:pos{m < n} ->
Lemma (requires (a % pow2 m == 0 /\ b < pow2 m))
(ensures (logor #n a b == a + b))
val logand_mask: #n:pos -> a:uint_t n -> m:pos{m < n} ->
Lemma (pow2 m < pow2 n /\ logand #n a (pow2 m - 1) == a % pow2 m)
(* Shift operators *)
let shift_left (#n:pos) (a:uint_t n) (s:nat) : Tot (uint_t n) =
from_vec (shift_left_vec #n (to_vec #n a) s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.BitVector.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BitVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.UInt.uint_t n -> s: Prims.nat -> FStar.UInt.uint_t n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"FStar.UInt.from_vec",
"FStar.BitVector.shift_right_vec",
"FStar.UInt.to_vec"
] | [] | false | false | false | false | false | let shift_right (#n: pos) (a: uint_t n) (s: nat) : Tot (uint_t n) =
| from_vec (shift_right_vec #n (to_vec #n a) s) | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.table_inv_w4 | val table_inv_w4:BE.table_inv_t U64 12ul 16ul | val table_inv_w4:BE.table_inv_t U64 12ul 16ul | let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 38,
"start_col": 0,
"start_line": 32
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.P256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.table_inv_t Lib.IntTypes.U64
(12ul <: FStar.UInt32.t)
(16ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.table_inv_precomp",
"Lib.IntTypes.U64",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops"
] | [] | false | false | false | false | false | let table_inv_w4:BE.table_inv_t U64 12ul 16ul =
| [@@ inline_let ]let len = 12ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_p256_concrete_ops in
[@@ inline_let ]let l = 4ul in
[@@ inline_let ]let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.point_mul | val point_mul: res:point -> scalar:felem -> p:point -> Stack unit
(requires fun h ->
live h p /\ live h res /\ live h scalar /\
disjoint p res /\ disjoint scalar res /\ disjoint p scalar /\
point_inv h p /\ as_nat h scalar < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
point_inv h1 res /\
S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul (as_nat h0 scalar) (from_mont_point (as_point_nat h0 p)))) | val point_mul: res:point -> scalar:felem -> p:point -> Stack unit
(requires fun h ->
live h p /\ live h res /\ live h scalar /\
disjoint p res /\ disjoint scalar res /\ disjoint p scalar /\
point_inv h p /\ as_nat h scalar < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
point_inv h1 res /\
S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul (as_nat h0 scalar) (from_mont_point (as_point_nat h0 p)))) | let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 57,
"start_col": 0,
"start_line": 53
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
res: Hacl.Impl.P256.Point.point ->
scalar: Hacl.Impl.P256.Bignum.felem ->
p: Hacl.Impl.P256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.Exponentiation.lexp_fw_consttime",
"Lib.IntTypes.U64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.unit",
"Spec.Exponentiation.exp_fw_lemma",
"Spec.P256.PointOps.proj_point",
"Spec.P256.mk_p256_concrete_ops",
"Hacl.Impl.P256.Point.from_mont_point",
"Hacl.Impl.P256.Point.as_point_nat",
"Hacl.Impl.P256.Bignum.as_nat",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let point_mul res scalar p =
| let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p))
256
(as_nat h0 scalar)
4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.table_inv_w5 | val table_inv_w5:BE.table_inv_t U64 12ul 32ul | val table_inv_w5:BE.table_inv_t U64 12ul 32ul | let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 49,
"start_col": 0,
"start_line": 42
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.P256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.table_inv_t Lib.IntTypes.U64
(12ul <: FStar.UInt32.t)
(32ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.table_inv_precomp",
"Lib.IntTypes.U64",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops"
] | [] | false | false | false | false | false | let table_inv_w5:BE.table_inv_t U64 12ul 32ul =
| [@@ inline_let ]let len = 12ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_p256_concrete_ops in
[@@ inline_let ]let l = 5ul in
[@@ inline_let ]let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len | false |
FStar.PredicateExtensionality.fst | FStar.PredicateExtensionality.peq | val peq : p1: FStar.PredicateExtensionality.predicate a -> p2: FStar.PredicateExtensionality.predicate a
-> Prims.logical | let peq (#a:Type) (p1:predicate a) (p2:predicate a) =
forall x. (p1 x <==> p2 x) | {
"file_name": "ulib/FStar.PredicateExtensionality.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | (*
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.PredicateExtensionality
module F = FStar.FunctionalExtensionality
module P = FStar.PropositionalExtensionality
let predicate (a:Type) = a -> Tot prop | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.PredicateExtensionality.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.PropositionalExtensionality",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: FStar.PredicateExtensionality.predicate a -> p2: FStar.PredicateExtensionality.predicate a
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.PredicateExtensionality.predicate",
"Prims.l_Forall",
"Prims.l_iff",
"Prims.logical"
] | [] | false | false | false | true | true | let peq (#a: Type) (p1 p2: predicate a) =
| forall x. (p1 x <==> p2 x) | false |
|
FStar.PredicateExtensionality.fst | FStar.PredicateExtensionality.predicate | val predicate : a: Type -> Type | let predicate (a:Type) = a -> Tot prop | {
"file_name": "ulib/FStar.PredicateExtensionality.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | (*
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.PredicateExtensionality
module F = FStar.FunctionalExtensionality
module P = FStar.PropositionalExtensionality | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.PredicateExtensionality.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.PropositionalExtensionality",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.prop"
] | [] | false | false | false | true | true | let predicate (a: Type) =
| a -> Tot prop | false |
|
FStar.PredicateExtensionality.fst | FStar.PredicateExtensionality.predicateExtensionality | val predicateExtensionality (a: Type) (p1 p2: predicate a)
: Lemma (requires (peq #a p1 p2)) (ensures (F.on_domain a p1 == F.on_domain a p2)) | val predicateExtensionality (a: Type) (p1 p2: predicate a)
: Lemma (requires (peq #a p1 p2)) (ensures (F.on_domain a p1 == F.on_domain a p2)) | let predicateExtensionality (a:Type) (p1 p2:predicate a)
: Lemma (requires (peq #a p1 p2))
(ensures (F.on_domain a p1==F.on_domain a p2))
= P.axiom();
assert (F.feq p1 p2) | {
"file_name": "ulib/FStar.PredicateExtensionality.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 29,
"start_col": 0,
"start_line": 25
} | (*
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.PredicateExtensionality
module F = FStar.FunctionalExtensionality
module P = FStar.PropositionalExtensionality
let predicate (a:Type) = a -> Tot prop
let peq (#a:Type) (p1:predicate a) (p2:predicate a) =
forall x. (p1 x <==> p2 x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.PredicateExtensionality.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.PropositionalExtensionality",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type ->
p1: FStar.PredicateExtensionality.predicate a ->
p2: FStar.PredicateExtensionality.predicate a
-> FStar.Pervasives.Lemma (requires FStar.PredicateExtensionality.peq p1 p2)
(ensures
FStar.FunctionalExtensionality.on_domain a p1 ==
FStar.FunctionalExtensionality.on_domain a p2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.PredicateExtensionality.predicate",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.prop",
"Prims.unit",
"FStar.PropositionalExtensionality.axiom",
"FStar.PredicateExtensionality.peq",
"Prims.squash",
"Prims.eq2",
"FStar.FunctionalExtensionality.arrow",
"FStar.FunctionalExtensionality.on_domain",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let predicateExtensionality (a: Type) (p1 p2: predicate a)
: Lemma (requires (peq #a p1 p2)) (ensures (F.on_domain a p1 == F.on_domain a p2)) =
| P.axiom ();
assert (F.feq p1 p2) | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.precomp_get_consttime | val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul) | val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul) | let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 70,
"start_col": 0,
"start_line": 63
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len
[@CInline]
let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.P256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.pow_a_to_small_b_st Lib.IntTypes.U64
12ul
0ul
Hacl.Impl.P256.Group.mk_p256_concrete_ops
4ul
16ul
(Hacl.Impl.Exponentiation.table_inv_precomp 12ul
0ul
Hacl.Impl.P256.Group.mk_p256_concrete_ops
4ul
16ul) | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"FStar.Ghost.erased",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.clbuffer",
"Lib.IntTypes.op_Star_Bang",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Hacl.Impl.Exponentiation.lprecomp_get_consttime",
"Prims.unit",
"FStar.UInt32.t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops"
] | [] | false | false | false | false | false | let precomp_get_consttime ctx a table bits_l tmp =
| [@@ inline_let ]let len = 12ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_p256_concrete_ops in
[@@ inline_let ]let l = 4ul in
[@@ inline_let ]let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.lemma_exp_four_fw_local | val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.order} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b))) | val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.order} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b))) | let lemma_exp_four_fw_local b =
let cm = S.mk_p256_comm_monoid in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.lemma_point_mul_base_precomp4 cm g_aff (BD.bn_v b);
assert (res == LE.pow cm g_aff (BD.bn_v b));
SE.exp_fw_lemma S.mk_p256_concrete_ops S.base_point 256 (BD.bn_v b) 4;
LE.exp_fw_lemma cm g_aff 256 (BD.bn_v b) 4;
assert (S.to_aff_point (S.point_mul_g (BD.bn_v b)) == LE.pow cm g_aff (BD.bn_v b)) | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 160,
"start_col": 0,
"start_line": 151
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len
[@CInline]
let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul)
[@CInline]
let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp
inline_for_extraction noextract
val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4))
let point_mul_g_noalloc out scalar q1 q2 q3 q4 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
[@inline_let] let bLen = 1ul in
[@inline_let] let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub scalar 0ul 1ul in
let r2 = sub scalar 1ul 1ul in
let r3 = sub scalar 2ul 1ul in
let r4 = sub scalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 scalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len
table_inv_w4 table_inv_w4 table_inv_w4 table_inv_w4
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
(null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4)
(to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4)
(to_const precomp_g_pow2_192_table_w4)
out
val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.order} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.P256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b:
Hacl.Spec.Bignum.Definitions.lbignum Lib.IntTypes.U64 4
{Hacl.Spec.Bignum.Definitions.bn_v b < Spec.P256.PointOps.order}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.PrecompBaseTable256.decompose_nat256_as_four_u64 (Hacl.Spec.Bignum.Definitions.bn_v
b)
in
(let FStar.Pervasives.Native.Mktuple4 #_ #_ #_ #_ b0 b1 b2 b3 = _ in
Lib.Exponentiation.exp_four_fw Spec.P256.mk_p256_comm_monoid Hacl.P256.PrecompTable.g_aff
64 b0 Hacl.P256.PrecompTable.g_pow2_64 b1 Hacl.P256.PrecompTable.g_pow2_128 b2
Hacl.P256.PrecompTable.g_pow2_192 b3 4 ==
Spec.P256.PointOps.to_aff_point (Spec.P256.point_mul_g (Hacl.Spec.Bignum.Definitions.bn_v b
)))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.U64",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Spec.P256.PointOps.order",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.aff_point",
"Spec.P256.PointOps.to_aff_point",
"Spec.P256.point_mul_g",
"Lib.Exponentiation.Definition.pow",
"Hacl.P256.PrecompTable.g_aff",
"Prims.unit",
"Lib.Exponentiation.exp_fw_lemma",
"Spec.Exponentiation.exp_fw_lemma",
"Spec.P256.PointOps.proj_point",
"Spec.P256.mk_p256_concrete_ops",
"Spec.P256.PointOps.base_point",
"Hacl.Spec.PrecompBaseTable256.lemma_point_mul_base_precomp4",
"Hacl.Spec.PrecompBaseTable256.exp_as_exp_four_nat256_precomp",
"Lib.Exponentiation.exp_four_fw",
"Hacl.P256.PrecompTable.g_pow2_64",
"Hacl.P256.PrecompTable.g_pow2_128",
"Hacl.P256.PrecompTable.g_pow2_192",
"FStar.Pervasives.Native.tuple4",
"Hacl.Spec.PrecompBaseTable256.decompose_nat256_as_four_u64",
"Lib.Exponentiation.Definition.comm_monoid",
"Spec.P256.mk_p256_comm_monoid"
] | [] | false | false | true | false | false | let lemma_exp_four_fw_local b =
| let cm = S.mk_p256_comm_monoid in
let b0, b1, b2, b3 = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.lemma_point_mul_base_precomp4 cm g_aff (BD.bn_v b);
assert (res == LE.pow cm g_aff (BD.bn_v b));
SE.exp_fw_lemma S.mk_p256_concrete_ops S.base_point 256 (BD.bn_v b) 4;
LE.exp_fw_lemma cm g_aff 256 (BD.bn_v b) 4;
assert (S.to_aff_point (S.point_mul_g (BD.bn_v b)) == LE.pow cm g_aff (BD.bn_v b)) | false |
Hacl.Impl.Ed25519.Verify.fst | Hacl.Impl.Ed25519.Verify.verify_all_valid_hb | val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool
(requires fun h ->
live h sb /\ live h hb /\ live h a' /\ live h r' /\
point_inv_full_t h a' /\ point_inv_full_t h r')
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z == Spec.Ed25519.(
let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in
point_equal exp_d (F51.point_eval h0 r')))) | val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool
(requires fun h ->
live h sb /\ live h hb /\ live h a' /\ live h r' /\
point_inv_full_t h a' /\ point_inv_full_t h r')
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z == Spec.Ed25519.(
let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in
point_equal exp_d (F51.point_eval h0 r')))) | let verify_all_valid_hb sb hb a' r' =
push_frame ();
let exp_d = create 20ul (u64 0) in
PM.point_negate_mul_double_g_vartime exp_d sb hb a';
let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_equal_lemma
(F51.point_eval h0 exp_d)
(Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a'))
(F51.point_eval h0 r');
pop_frame ();
b | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 45,
"start_col": 0,
"start_line": 34
} | module Hacl.Impl.Ed25519.Verify
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module PM = Hacl.Impl.Ed25519.Ladder
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let point_inv_full_t (h:mem) (p:point) =
F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p)
inline_for_extraction noextract
val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool
(requires fun h ->
live h sb /\ live h hb /\ live h a' /\ live h r' /\
point_inv_full_t h a' /\ point_inv_full_t h r')
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z == Spec.Ed25519.(
let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in
point_equal exp_d (F51.point_eval h0 r')))) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointEqual.fst.checked",
"Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Ladder",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
sb: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
hb: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
a': Hacl.Bignum25519.point ->
r': Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum25519.point",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Spec.Ed25519.Lemmas.point_equal_lemma",
"Hacl.Impl.Ed25519.Field51.point_eval",
"Spec.Ed25519.point_negate_mul_double_g",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.Ed25519.PointEqual.point_equal",
"Hacl.Impl.Ed25519.Ladder.point_negate_mul_double_g_vartime",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let verify_all_valid_hb sb hb a' r' =
| push_frame ();
let exp_d = create 20ul (u64 0) in
PM.point_negate_mul_double_g_vartime exp_d sb hb a';
let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_equal_lemma (F51.point_eval h0 exp_d)
(Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a'))
(F51.point_eval h0 r');
pop_frame ();
b | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.point_mul_g_double_vartime_noalloc | val point_mul_g_double_vartime_noalloc:
out:point
-> scalar1:felem -> q1:point
-> scalar2:felem -> q2:point
-> table2:lbuffer uint64 (32ul *! 12ul) ->
Stack unit
(requires fun h ->
live h out /\ live h scalar1 /\ live h q1 /\
live h scalar2 /\ live h q2 /\ live h table2 /\
eq_or_disjoint q1 q2 /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out scalar1 /\ disjoint out scalar2 /\ disjoint out table2 /\
as_nat h scalar1 < S.order /\ as_nat h scalar2 < S.order /\
point_inv h q1 /\ from_mont_point (as_point_nat h q1) == S.base_point /\
point_inv h q2 /\ table_inv_w5 (as_seq h q2) (as_seq h table2))
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
refl (as_seq h1 out) ==
S.to_aff_point (S.point_mul_double_g
(as_nat h0 scalar1) (as_nat h0 scalar2) (from_mont_point (as_point_nat h0 q2)))) | val point_mul_g_double_vartime_noalloc:
out:point
-> scalar1:felem -> q1:point
-> scalar2:felem -> q2:point
-> table2:lbuffer uint64 (32ul *! 12ul) ->
Stack unit
(requires fun h ->
live h out /\ live h scalar1 /\ live h q1 /\
live h scalar2 /\ live h q2 /\ live h table2 /\
eq_or_disjoint q1 q2 /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out scalar1 /\ disjoint out scalar2 /\ disjoint out table2 /\
as_nat h scalar1 < S.order /\ as_nat h scalar2 < S.order /\
point_inv h q1 /\ from_mont_point (as_point_nat h q1) == S.base_point /\
point_inv h q2 /\ table_inv_w5 (as_seq h q2) (as_seq h table2))
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
refl (as_seq h1 out) ==
S.to_aff_point (S.point_mul_double_g
(as_nat h0 scalar1) (as_nat h0 scalar2) (from_mont_point (as_point_nat h0 q2)))) | let point_mul_g_double_vartime_noalloc out scalar1 q1 scalar2 q2 table2 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
[@inline_let] let bLen = 4ul in
[@inline_let] let bBits = 256ul in
assert_norm (pow2 (v l) == v table_len);
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w5 precomp_basepoint_table_lseq_w5;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w5 ();
assert (table_inv_w5 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w5));
assert (table_inv_w5 (as_seq h1 q2) (as_seq h1 table2));
ME.mk_lexp_double_fw_tables len ctx_len k l table_len
table_inv_w5 table_inv_w5
(BE.lprecomp_get_vartime len ctx_len k l table_len)
(BE.lprecomp_get_vartime len ctx_len k l table_len)
(null uint64) q1 bLen bBits scalar1 q2 scalar2
(to_const precomp_basepoint_table_w5) (to_const table2) out;
SE.exp_double_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 q1)) 256 (as_nat h0 scalar1)
(from_mont_point (as_point_nat h0 q2)) (as_nat h0 scalar2) 5 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 234,
"start_col": 0,
"start_line": 208
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len
[@CInline]
let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul)
[@CInline]
let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp
inline_for_extraction noextract
val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4))
let point_mul_g_noalloc out scalar q1 q2 q3 q4 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
[@inline_let] let bLen = 1ul in
[@inline_let] let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub scalar 0ul 1ul in
let r2 = sub scalar 1ul 1ul in
let r3 = sub scalar 2ul 1ul in
let r4 = sub scalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 scalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len
table_inv_w4 table_inv_w4 table_inv_w4 table_inv_w4
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
(null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4)
(to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4)
(to_const precomp_g_pow2_192_table_w4)
out
val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.order} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b)))
let lemma_exp_four_fw_local b =
let cm = S.mk_p256_comm_monoid in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.lemma_point_mul_base_precomp4 cm g_aff (BD.bn_v b);
assert (res == LE.pow cm g_aff (BD.bn_v b));
SE.exp_fw_lemma S.mk_p256_concrete_ops S.base_point 256 (BD.bn_v b) 4;
LE.exp_fw_lemma cm g_aff 256 (BD.bn_v b) 4;
assert (S.to_aff_point (S.point_mul_g (BD.bn_v b)) == LE.pow cm g_aff (BD.bn_v b))
[@CInline]
let point_mul_g res scalar =
push_frame ();
let h0 = ST.get () in
let q1 = create_point () in
make_base_point q1;
let q2 = mk_proj_g_pow2_64 () in
let q3 = mk_proj_g_pow2_128 () in
let q4 = mk_proj_g_pow2_192 () in
proj_g_pow2_64_lseq_lemma ();
proj_g_pow2_128_lseq_lemma ();
proj_g_pow2_192_lseq_lemma ();
point_mul_g_noalloc res scalar q1 q2 q3 q4;
LowStar.Ignore.ignore q1;
LowStar.Ignore.ignore q2;
LowStar.Ignore.ignore q3;
LowStar.Ignore.ignore q4;
lemma_exp_four_fw_local (as_seq h0 scalar);
pop_frame ()
//-------------------------
inline_for_extraction noextract
val point_mul_g_double_vartime_noalloc:
out:point
-> scalar1:felem -> q1:point
-> scalar2:felem -> q2:point
-> table2:lbuffer uint64 (32ul *! 12ul) ->
Stack unit
(requires fun h ->
live h out /\ live h scalar1 /\ live h q1 /\
live h scalar2 /\ live h q2 /\ live h table2 /\
eq_or_disjoint q1 q2 /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out scalar1 /\ disjoint out scalar2 /\ disjoint out table2 /\
as_nat h scalar1 < S.order /\ as_nat h scalar2 < S.order /\
point_inv h q1 /\ from_mont_point (as_point_nat h q1) == S.base_point /\
point_inv h q2 /\ table_inv_w5 (as_seq h q2) (as_seq h table2))
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
refl (as_seq h1 out) ==
S.to_aff_point (S.point_mul_double_g
(as_nat h0 scalar1) (as_nat h0 scalar2) (from_mont_point (as_point_nat h0 q2)))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.P256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: Hacl.Impl.P256.Point.point ->
scalar1: Hacl.Impl.P256.Bignum.felem ->
q1: Hacl.Impl.P256.Point.point ->
scalar2: Hacl.Impl.P256.Bignum.felem ->
q2: Hacl.Impl.P256.Point.point ->
table2: Lib.Buffer.lbuffer Lib.IntTypes.uint64 (32ul *! 12ul)
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.felem",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.UInt32.__uint_to_t",
"Spec.Exponentiation.exp_double_fw_lemma",
"Spec.P256.PointOps.proj_point",
"Spec.P256.mk_p256_concrete_ops",
"Hacl.Impl.P256.Point.from_mont_point",
"Hacl.Impl.P256.Point.as_point_nat",
"Hacl.Impl.P256.Bignum.as_nat",
"Prims.unit",
"Hacl.Impl.MultiExponentiation.mk_lexp_double_fw_tables",
"Lib.IntTypes.U64",
"Hacl.Impl.P256.PointMul.table_inv_w5",
"Hacl.Impl.Exponentiation.lprecomp_get_vartime",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.Buffer.to_const",
"Lib.Buffer.CONST",
"Hacl.P256.PrecompTable.precomp_basepoint_table_w5",
"Prims._assert",
"Lib.Buffer.as_seq",
"Hacl.P256.PrecompTable.precomp_basepoint_table_lemma_w5",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.Buffer.recall_contents",
"Hacl.P256.PrecompTable.precomp_basepoint_table_lseq_w5",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.range",
"Prims.pow2",
"Lib.IntTypes.v",
"FStar.UInt32.t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops"
] | [] | false | true | false | false | false | let point_mul_g_double_vartime_noalloc out scalar1 q1 scalar2 q2 table2 =
| [@@ inline_let ]let len = 12ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_p256_concrete_ops in
[@@ inline_let ]let l = 5ul in
[@@ inline_let ]let table_len = 32ul in
[@@ inline_let ]let bLen = 4ul in
[@@ inline_let ]let bBits = 256ul in
assert_norm (pow2 (v l) == v table_len);
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w5 precomp_basepoint_table_lseq_w5;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w5 ();
assert (table_inv_w5 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w5));
assert (table_inv_w5 (as_seq h1 q2) (as_seq h1 table2));
ME.mk_lexp_double_fw_tables len ctx_len k l table_len table_inv_w5 table_inv_w5
(BE.lprecomp_get_vartime len ctx_len k l table_len)
(BE.lprecomp_get_vartime len ctx_len k l table_len) (null uint64) q1 bLen bBits scalar1 q2 scalar2
(to_const precomp_basepoint_table_w5) (to_const table2) out;
SE.exp_double_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 q1))
256
(as_nat h0 scalar1)
(from_mont_point (as_point_nat h0 q2))
(as_nat h0 scalar2)
5 | false |
Hacl.Impl.Ed25519.PointAdd.fst | Hacl.Impl.Ed25519.PointAdd.point_add | val point_add: out:point -> p:point -> q:point -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q)) | val point_add: out:point -> p:point -> q:point -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q)) | let point_add out p q =
push_frame();
let tmp = create 30ul (u64 0) in
point_add_ out p q tmp;
pop_frame() | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 145,
"start_col": 0,
"start_line": 141
} | module Hacl.Impl.Ed25519.PointAdd
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val point_add_step_1: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let x1 = F51.fevalh h0 (gsub p 0ul 5ul) in
let y1 = F51.fevalh h0 (gsub p 5ul 5ul) in
let x2 = F51.fevalh h0 (gsub q 0ul 5ul) in
let y2 = F51.fevalh h0 (gsub q 5ul 5ul) in
let a = (y1 `SC.fsub` x1) `SC.fmul` (y2 `SC.fsub` x2) in
let b = (y1 `SC.fadd` x1) `SC.fmul` (y2 `SC.fadd` x2) in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h1 (gsub tmp 15ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == a /\
F51.fevalh h1 (gsub tmp 15ul 5ul) == b))
let point_add_step_1 p q tmp =
let tmp1 = sub tmp 0ul 5ul in
let tmp2 = sub tmp 5ul 5ul in
let tmp3 = sub tmp 10ul 5ul in
let tmp4 = sub tmp 15ul 5ul in
let x1 = getx p in
let y1 = gety p in
let x2 = getx q in
let y2 = gety q in
fdifference tmp1 y1 x1; // tmp1 = y1 - x1
fdifference tmp2 y2 x2; // tmp2 = y2 - x2
fmul tmp3 tmp1 tmp2; // tmp3 = a
fsum tmp1 y1 x1; // tmp1 = y1 + x1
fsum tmp2 y2 x2; // tmp2 = y2 + x2
fmul tmp4 tmp1 tmp2 // tmp4 = b
inline_for_extraction noextract
val point_add_step_2: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q /\
F51.mul_inv_t h (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h (gsub tmp 15ul 5ul))
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let z1 = F51.fevalh h0 (gsub p 10ul 5ul) in
let t1 = F51.fevalh h0 (gsub p 15ul 5ul) in
let z2 = F51.fevalh h0 (gsub q 10ul 5ul) in
let t2 = F51.fevalh h0 (gsub q 15ul 5ul) in
let a = F51.fevalh h0 (gsub tmp 10ul 5ul) in
let b = F51.fevalh h0 (gsub tmp 15ul 5ul) in
let c = (2 `SC.fmul` Spec.Ed25519.d `SC.fmul` t1) `SC.fmul` t2 in
let d = (2 `SC.fmul` z1) `SC.fmul` z2 in
let e = b `SC.fsub` a in
let f = d `SC.fsub` c in
let g = d `SC.fadd` c in
let h = b `SC.fadd` a in
F51.felem_fits h1 (gsub tmp 20ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 25ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 0ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 5ul 5ul) (9, 10, 9, 9, 9) /\
F51.fevalh h1 (gsub tmp 20ul 5ul) == e /\
F51.fevalh h1 (gsub tmp 25ul 5ul) == f /\
F51.fevalh h1 (gsub tmp 0ul 5ul) == g /\
F51.fevalh h1 (gsub tmp 5ul 5ul) == h))
let point_add_step_2 p q tmp =
let tmp1 = sub tmp 0ul 5ul in // g
let tmp2 = sub tmp 5ul 5ul in // h
let tmp3 = sub tmp 10ul 5ul in // a
let tmp4 = sub tmp 15ul 5ul in // b
let tmp5 = sub tmp 20ul 5ul in // e
let tmp6 = sub tmp 25ul 5ul in // f
let z1 = getz p in
let t1 = gett p in
let z2 = getz q in
let t2 = gett q in
times_2d tmp1 t1; // tmp1 = 2 * d * t1
fmul tmp1 tmp1 t2; // tmp1 = tmp1 * t2 = c
times_2 tmp2 z1; // tmp2 = 2 * z1
fmul tmp2 tmp2 z2; // tmp2 = tmp2 * z2 = d
fdifference tmp5 tmp4 tmp3; // tmp5 = e = b - a = tmp4 - tmp3
fdifference tmp6 tmp2 tmp1; // tmp6 = f = d - c = tmp2 - tmp1
fsum tmp1 tmp2 tmp1; // tmp1 = g = d + c = tmp2 + tmp1
fsum tmp2 tmp4 tmp3 // tmp2 = h = b + a = tmp4 - tmp3
inline_for_extraction noextract
val point_add_: out:point -> p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\ disjoint tmp out /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q))
let point_add_ out p q tmp =
point_add_step_1 p q tmp;
point_add_step_2 p q tmp;
let tmp_g = sub tmp 0ul 5ul in
let tmp_h = sub tmp 5ul 5ul in
let tmp_e = sub tmp 20ul 5ul in
let tmp_f = sub tmp 25ul 5ul in
let x3 = getx out in
let y3 = gety out in
let z3 = getz out in
let t3 = gett out in
fmul x3 tmp_e tmp_f;
fmul y3 tmp_g tmp_h;
fmul t3 tmp_e tmp_h;
fmul z3 tmp_f tmp_g
val point_add: out:point -> p:point -> q:point -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointAdd.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | out: Hacl.Bignum25519.point -> p: Hacl.Bignum25519.point -> q: Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.point",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Ed25519.PointAdd.point_add_",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.u64",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let point_add out p q =
| push_frame ();
let tmp = create 30ul (u64 0) in
point_add_ out p q tmp;
pop_frame () | false |
Hacl.Impl.Ed25519.PointAdd.fst | Hacl.Impl.Ed25519.PointAdd.point_add_ | val point_add_: out:point -> p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\ disjoint tmp out /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q)) | val point_add_: out:point -> p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\ disjoint tmp out /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q)) | let point_add_ out p q tmp =
point_add_step_1 p q tmp;
point_add_step_2 p q tmp;
let tmp_g = sub tmp 0ul 5ul in
let tmp_h = sub tmp 5ul 5ul in
let tmp_e = sub tmp 20ul 5ul in
let tmp_f = sub tmp 25ul 5ul in
let x3 = getx out in
let y3 = gety out in
let z3 = getz out in
let t3 = gett out in
fmul x3 tmp_e tmp_f;
fmul y3 tmp_g tmp_h;
fmul t3 tmp_e tmp_h;
fmul z3 tmp_f tmp_g | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 129,
"start_col": 0,
"start_line": 115
} | module Hacl.Impl.Ed25519.PointAdd
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val point_add_step_1: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let x1 = F51.fevalh h0 (gsub p 0ul 5ul) in
let y1 = F51.fevalh h0 (gsub p 5ul 5ul) in
let x2 = F51.fevalh h0 (gsub q 0ul 5ul) in
let y2 = F51.fevalh h0 (gsub q 5ul 5ul) in
let a = (y1 `SC.fsub` x1) `SC.fmul` (y2 `SC.fsub` x2) in
let b = (y1 `SC.fadd` x1) `SC.fmul` (y2 `SC.fadd` x2) in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h1 (gsub tmp 15ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == a /\
F51.fevalh h1 (gsub tmp 15ul 5ul) == b))
let point_add_step_1 p q tmp =
let tmp1 = sub tmp 0ul 5ul in
let tmp2 = sub tmp 5ul 5ul in
let tmp3 = sub tmp 10ul 5ul in
let tmp4 = sub tmp 15ul 5ul in
let x1 = getx p in
let y1 = gety p in
let x2 = getx q in
let y2 = gety q in
fdifference tmp1 y1 x1; // tmp1 = y1 - x1
fdifference tmp2 y2 x2; // tmp2 = y2 - x2
fmul tmp3 tmp1 tmp2; // tmp3 = a
fsum tmp1 y1 x1; // tmp1 = y1 + x1
fsum tmp2 y2 x2; // tmp2 = y2 + x2
fmul tmp4 tmp1 tmp2 // tmp4 = b
inline_for_extraction noextract
val point_add_step_2: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q /\
F51.mul_inv_t h (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h (gsub tmp 15ul 5ul))
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let z1 = F51.fevalh h0 (gsub p 10ul 5ul) in
let t1 = F51.fevalh h0 (gsub p 15ul 5ul) in
let z2 = F51.fevalh h0 (gsub q 10ul 5ul) in
let t2 = F51.fevalh h0 (gsub q 15ul 5ul) in
let a = F51.fevalh h0 (gsub tmp 10ul 5ul) in
let b = F51.fevalh h0 (gsub tmp 15ul 5ul) in
let c = (2 `SC.fmul` Spec.Ed25519.d `SC.fmul` t1) `SC.fmul` t2 in
let d = (2 `SC.fmul` z1) `SC.fmul` z2 in
let e = b `SC.fsub` a in
let f = d `SC.fsub` c in
let g = d `SC.fadd` c in
let h = b `SC.fadd` a in
F51.felem_fits h1 (gsub tmp 20ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 25ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 0ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 5ul 5ul) (9, 10, 9, 9, 9) /\
F51.fevalh h1 (gsub tmp 20ul 5ul) == e /\
F51.fevalh h1 (gsub tmp 25ul 5ul) == f /\
F51.fevalh h1 (gsub tmp 0ul 5ul) == g /\
F51.fevalh h1 (gsub tmp 5ul 5ul) == h))
let point_add_step_2 p q tmp =
let tmp1 = sub tmp 0ul 5ul in // g
let tmp2 = sub tmp 5ul 5ul in // h
let tmp3 = sub tmp 10ul 5ul in // a
let tmp4 = sub tmp 15ul 5ul in // b
let tmp5 = sub tmp 20ul 5ul in // e
let tmp6 = sub tmp 25ul 5ul in // f
let z1 = getz p in
let t1 = gett p in
let z2 = getz q in
let t2 = gett q in
times_2d tmp1 t1; // tmp1 = 2 * d * t1
fmul tmp1 tmp1 t2; // tmp1 = tmp1 * t2 = c
times_2 tmp2 z1; // tmp2 = 2 * z1
fmul tmp2 tmp2 z2; // tmp2 = tmp2 * z2 = d
fdifference tmp5 tmp4 tmp3; // tmp5 = e = b - a = tmp4 - tmp3
fdifference tmp6 tmp2 tmp1; // tmp6 = f = d - c = tmp2 - tmp1
fsum tmp1 tmp2 tmp1; // tmp1 = g = d + c = tmp2 + tmp1
fsum tmp2 tmp4 tmp3 // tmp2 = h = b + a = tmp4 - tmp3
inline_for_extraction noextract
val point_add_: out:point -> p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h out /\ live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\ disjoint tmp out /\
eq_or_disjoint p out /\ eq_or_disjoint q out /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
F51.point_inv_t h1 out /\
F51.point_eval h1 out == Spec.Ed25519.point_add (F51.point_eval h0 p) (F51.point_eval h0 q)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointAdd.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: Hacl.Bignum25519.point ->
p: Hacl.Bignum25519.point ->
q: Hacl.Bignum25519.point ->
tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 30ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum25519.fmul",
"Prims.unit",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.gett",
"Hacl.Bignum25519.getz",
"Hacl.Bignum25519.gety",
"Hacl.Bignum25519.getx",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"Hacl.Impl.Ed25519.PointAdd.point_add_step_2",
"Hacl.Impl.Ed25519.PointAdd.point_add_step_1"
] | [] | false | true | false | false | false | let point_add_ out p q tmp =
| point_add_step_1 p q tmp;
point_add_step_2 p q tmp;
let tmp_g = sub tmp 0ul 5ul in
let tmp_h = sub tmp 5ul 5ul in
let tmp_e = sub tmp 20ul 5ul in
let tmp_f = sub tmp 25ul 5ul in
let x3 = getx out in
let y3 = gety out in
let z3 = getz out in
let t3 = gett out in
fmul x3 tmp_e tmp_f;
fmul y3 tmp_g tmp_h;
fmul t3 tmp_e tmp_h;
fmul z3 tmp_f tmp_g | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.point_mul_g_noalloc | val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4)) | val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4)) | let point_mul_g_noalloc out scalar q1 q2 q3 q4 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
[@inline_let] let bLen = 1ul in
[@inline_let] let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub scalar 0ul 1ul in
let r2 = sub scalar 1ul 1ul in
let r3 = sub scalar 2ul 1ul in
let r4 = sub scalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 scalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len
table_inv_w4 table_inv_w4 table_inv_w4 table_inv_w4
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
(null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4)
(to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4)
(to_const precomp_g_pow2_192_table_w4)
out | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 143,
"start_col": 0,
"start_line": 96
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len
[@CInline]
let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul)
[@CInline]
let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp
inline_for_extraction noextract
val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4)) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.P256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: Hacl.Impl.P256.Point.point ->
scalar: Hacl.Impl.P256.Bignum.felem ->
q1: Hacl.Impl.P256.Point.point ->
q2: Hacl.Impl.P256.Point.point ->
q3: Hacl.Impl.P256.Point.point ->
q4: Hacl.Impl.P256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.MultiExponentiation.mk_lexp_four_fw_tables",
"Lib.IntTypes.U64",
"Hacl.Impl.P256.PointMul.table_inv_w4",
"Hacl.Impl.P256.PointMul.precomp_get_consttime",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Lib.Buffer.to_const",
"Lib.Buffer.CONST",
"Hacl.P256.PrecompTable.precomp_basepoint_table_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_64_table_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_128_table_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_192_table_w4",
"Prims.unit",
"Hacl.Spec.PrecompBaseTable256.lemma_decompose_nat256_as_four_u64_lbignum",
"Lib.Buffer.as_seq",
"Lib.IntTypes.size",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"FStar.UInt32.__uint_to_t",
"Prims._assert",
"Hacl.P256.PrecompTable.precomp_g_pow2_192_table_lemma_w4",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.Buffer.recall_contents",
"Hacl.P256.PrecompTable.precomp_g_pow2_192_table_lseq_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_128_table_lemma_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_128_table_lseq_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_64_table_lemma_w4",
"Hacl.P256.PrecompTable.precomp_g_pow2_64_table_lseq_w4",
"Hacl.P256.PrecompTable.precomp_basepoint_table_lemma_w4",
"Hacl.P256.PrecompTable.precomp_basepoint_table_lseq_w4",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops"
] | [] | false | true | false | false | false | let point_mul_g_noalloc out scalar q1 q2 q3 q4 =
| [@@ inline_let ]let len = 12ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_p256_concrete_ops in
[@@ inline_let ]let l = 4ul in
[@@ inline_let ]let table_len = 16ul in
[@@ inline_let ]let bLen = 1ul in
[@@ inline_let ]let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub scalar 0ul 1ul in
let r2 = sub scalar 1ul 1ul in
let r3 = sub scalar 2ul 1ul in
let r4 = sub scalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 scalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len table_inv_w4 table_inv_w4 table_inv_w4
table_inv_w4 precomp_get_consttime precomp_get_consttime precomp_get_consttime
precomp_get_consttime (null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4) (to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4) (to_const precomp_g_pow2_192_table_w4) out | false |
Hacl.Impl.Ed25519.Verify.fst | Hacl.Impl.Ed25519.Verify.verify_valid_pk | val verify_valid_pk:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | val verify_valid_pk:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | let verify_valid_pk public_key msg_len msg signature a' =
push_frame ();
let r' = create 20ul (u64 0) in
let rs = sub signature 0ul 32ul in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 rs);
let b' = Hacl.Impl.Ed25519.PointDecompress.point_decompress r' rs in
let res = if b' then verify_valid_pk_rs public_key msg_len msg signature a' r' else false in
pop_frame ();
res | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 121,
"start_col": 0,
"start_line": 112
} | module Hacl.Impl.Ed25519.Verify
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module PM = Hacl.Impl.Ed25519.Ladder
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let point_inv_full_t (h:mem) (p:point) =
F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p)
inline_for_extraction noextract
val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool
(requires fun h ->
live h sb /\ live h hb /\ live h a' /\ live h r' /\
point_inv_full_t h a' /\ point_inv_full_t h r')
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z == Spec.Ed25519.(
let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in
point_equal exp_d (F51.point_eval h0 r'))))
let verify_all_valid_hb sb hb a' r' =
push_frame ();
let exp_d = create 20ul (u64 0) in
PM.point_negate_mul_double_g_vartime exp_d sb hb a';
let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_equal_lemma
(F51.point_eval h0 exp_d)
(Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a'))
(F51.point_eval h0 r');
pop_frame ();
b
inline_for_extraction noextract
val verify_sb: sb:lbuffer uint8 32ul -> Stack bool
(requires fun h -> live h sb)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q)))
let verify_sb sb =
push_frame ();
let tmp = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes tmp sb;
let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in
pop_frame ();
b
inline_for_extraction noextract
val verify_valid_pk_rs:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point
-> r':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\
(Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\
(F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))
let verify_valid_pk_rs public_key msg_len msg signature a' r' =
push_frame ();
let hb = create 32ul (u8 0) in
let rs = sub signature 0ul 32ul in
let sb = sub signature 32ul 32ul in
let b = verify_sb sb in
let res =
if b then false
else begin
Hacl.Impl.SHA512.ModQ.store_sha512_modq_pre_pre2 hb rs public_key msg_len msg;
verify_all_valid_hb sb hb a' r' end in
pop_frame ();
res
inline_for_extraction noextract
val verify_valid_pk:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointEqual.fst.checked",
"Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Ladder",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
public_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
msg_len: Lib.IntTypes.size_t ->
msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msg_len ->
signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul ->
a': Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum25519.point",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.Ed25519.Verify.verify_valid_pk_rs",
"Hacl.Impl.Ed25519.PointDecompress.point_decompress",
"Spec.Ed25519.Lemmas.point_decompress_lemma",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"Lib.IntTypes.U64",
"Lib.Buffer.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let verify_valid_pk public_key msg_len msg signature a' =
| push_frame ();
let r' = create 20ul (u64 0) in
let rs = sub signature 0ul 32ul in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 rs);
let b' = Hacl.Impl.Ed25519.PointDecompress.point_decompress r' rs in
let res = if b' then verify_valid_pk_rs public_key msg_len msg signature a' r' else false in
pop_frame ();
res | false |
Hacl.Impl.Ed25519.PointAdd.fst | Hacl.Impl.Ed25519.PointAdd.point_add_step_1 | val point_add_step_1: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let x1 = F51.fevalh h0 (gsub p 0ul 5ul) in
let y1 = F51.fevalh h0 (gsub p 5ul 5ul) in
let x2 = F51.fevalh h0 (gsub q 0ul 5ul) in
let y2 = F51.fevalh h0 (gsub q 5ul 5ul) in
let a = (y1 `SC.fsub` x1) `SC.fmul` (y2 `SC.fsub` x2) in
let b = (y1 `SC.fadd` x1) `SC.fmul` (y2 `SC.fadd` x2) in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h1 (gsub tmp 15ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == a /\
F51.fevalh h1 (gsub tmp 15ul 5ul) == b)) | val point_add_step_1: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let x1 = F51.fevalh h0 (gsub p 0ul 5ul) in
let y1 = F51.fevalh h0 (gsub p 5ul 5ul) in
let x2 = F51.fevalh h0 (gsub q 0ul 5ul) in
let y2 = F51.fevalh h0 (gsub q 5ul 5ul) in
let a = (y1 `SC.fsub` x1) `SC.fmul` (y2 `SC.fsub` x2) in
let b = (y1 `SC.fadd` x1) `SC.fmul` (y2 `SC.fadd` x2) in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h1 (gsub tmp 15ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == a /\
F51.fevalh h1 (gsub tmp 15ul 5ul) == b)) | let point_add_step_1 p q tmp =
let tmp1 = sub tmp 0ul 5ul in
let tmp2 = sub tmp 5ul 5ul in
let tmp3 = sub tmp 10ul 5ul in
let tmp4 = sub tmp 15ul 5ul in
let x1 = getx p in
let y1 = gety p in
let x2 = getx q in
let y2 = gety q in
fdifference tmp1 y1 x1; // tmp1 = y1 - x1
fdifference tmp2 y2 x2; // tmp2 = y2 - x2
fmul tmp3 tmp1 tmp2; // tmp3 = a
fsum tmp1 y1 x1; // tmp1 = y1 + x1
fsum tmp2 y2 x2; // tmp2 = y2 + x2
fmul tmp4 tmp1 tmp2 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 48,
"start_col": 0,
"start_line": 34
} | module Hacl.Impl.Ed25519.PointAdd
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val point_add_step_1: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let x1 = F51.fevalh h0 (gsub p 0ul 5ul) in
let y1 = F51.fevalh h0 (gsub p 5ul 5ul) in
let x2 = F51.fevalh h0 (gsub q 0ul 5ul) in
let y2 = F51.fevalh h0 (gsub q 5ul 5ul) in
let a = (y1 `SC.fsub` x1) `SC.fmul` (y2 `SC.fsub` x2) in
let b = (y1 `SC.fadd` x1) `SC.fmul` (y2 `SC.fadd` x2) in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h1 (gsub tmp 15ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == a /\
F51.fevalh h1 (gsub tmp 15ul 5ul) == b)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointAdd.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p: Hacl.Bignum25519.point ->
q: Hacl.Bignum25519.point ->
tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 30ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum25519.fmul",
"Prims.unit",
"Hacl.Bignum25519.fsum",
"Hacl.Bignum25519.fdifference",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.gety",
"Hacl.Bignum25519.getx",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub"
] | [] | false | true | false | false | false | let point_add_step_1 p q tmp =
| let tmp1 = sub tmp 0ul 5ul in
let tmp2 = sub tmp 5ul 5ul in
let tmp3 = sub tmp 10ul 5ul in
let tmp4 = sub tmp 15ul 5ul in
let x1 = getx p in
let y1 = gety p in
let x2 = getx q in
let y2 = gety q in
fdifference tmp1 y1 x1;
fdifference tmp2 y2 x2;
fmul tmp3 tmp1 tmp2;
fsum tmp1 y1 x1;
fsum tmp2 y2 x2;
fmul tmp4 tmp1 tmp2 | false |
Hacl.Impl.P256.Sign.fst | Hacl.Impl.P256.Sign.lbytes | val lbytes : len: Lib.IntTypes.size_t -> Type0 | let lbytes len = lbuffer uint8 len | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 26,
"start_col": 0,
"start_line": 26
} | module Hacl.Impl.P256.Sign
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.PointMul
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
module BB = Hacl.Bignum.Base
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --ifuel 0 --fuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | len: Lib.IntTypes.size_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8"
] | [] | false | false | false | true | true | let lbytes len =
| lbuffer uint8 len | false |
|
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.point_mul_double_g | val point_mul_double_g: res:point -> scalar1:felem -> scalar2:felem -> p:point -> Stack unit
(requires fun h ->
live h res /\ live h scalar1 /\ live h scalar2 /\ live h p /\
disjoint res scalar1 /\ disjoint res scalar2 /\ disjoint res p /\
disjoint p scalar1 /\ disjoint p scalar2 /\
point_inv h p /\ as_nat h scalar1 < S.order /\ as_nat h scalar2 < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
point_inv h1 res /\
S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul_double_g (as_nat h0 scalar1) (as_nat h0 scalar2)
(from_mont_point (as_point_nat h0 p)))) | val point_mul_double_g: res:point -> scalar1:felem -> scalar2:felem -> p:point -> Stack unit
(requires fun h ->
live h res /\ live h scalar1 /\ live h scalar2 /\ live h p /\
disjoint res scalar1 /\ disjoint res scalar2 /\ disjoint res p /\
disjoint p scalar1 /\ disjoint p scalar2 /\
point_inv h p /\ as_nat h scalar1 < S.order /\ as_nat h scalar2 < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
point_inv h1 res /\
S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul_double_g (as_nat h0 scalar1) (as_nat h0 scalar2)
(from_mont_point (as_point_nat h0 p)))) | let point_mul_double_g res scalar1 scalar2 q2 =
push_frame ();
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 5 == v table_len);
let q1 = create_point () in
make_base_point q1;
let table2 = create (table_len *! len) (u64 0) in
PT.lprecomp_table len ctx_len k (null uint64) q2 table_len table2;
let h = ST.get () in
assert (table_inv_w5 (as_seq h q2) (as_seq h table2));
point_mul_g_double_vartime_noalloc res scalar1 q1 scalar2 q2 table2;
pop_frame () | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 254,
"start_col": 0,
"start_line": 238
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len
[@CInline]
let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul)
[@CInline]
let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp
inline_for_extraction noextract
val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4))
let point_mul_g_noalloc out scalar q1 q2 q3 q4 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
[@inline_let] let bLen = 1ul in
[@inline_let] let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub scalar 0ul 1ul in
let r2 = sub scalar 1ul 1ul in
let r3 = sub scalar 2ul 1ul in
let r4 = sub scalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 scalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len
table_inv_w4 table_inv_w4 table_inv_w4 table_inv_w4
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
(null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4)
(to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4)
(to_const precomp_g_pow2_192_table_w4)
out
val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.order} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b)))
let lemma_exp_four_fw_local b =
let cm = S.mk_p256_comm_monoid in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.lemma_point_mul_base_precomp4 cm g_aff (BD.bn_v b);
assert (res == LE.pow cm g_aff (BD.bn_v b));
SE.exp_fw_lemma S.mk_p256_concrete_ops S.base_point 256 (BD.bn_v b) 4;
LE.exp_fw_lemma cm g_aff 256 (BD.bn_v b) 4;
assert (S.to_aff_point (S.point_mul_g (BD.bn_v b)) == LE.pow cm g_aff (BD.bn_v b))
[@CInline]
let point_mul_g res scalar =
push_frame ();
let h0 = ST.get () in
let q1 = create_point () in
make_base_point q1;
let q2 = mk_proj_g_pow2_64 () in
let q3 = mk_proj_g_pow2_128 () in
let q4 = mk_proj_g_pow2_192 () in
proj_g_pow2_64_lseq_lemma ();
proj_g_pow2_128_lseq_lemma ();
proj_g_pow2_192_lseq_lemma ();
point_mul_g_noalloc res scalar q1 q2 q3 q4;
LowStar.Ignore.ignore q1;
LowStar.Ignore.ignore q2;
LowStar.Ignore.ignore q3;
LowStar.Ignore.ignore q4;
lemma_exp_four_fw_local (as_seq h0 scalar);
pop_frame ()
//-------------------------
inline_for_extraction noextract
val point_mul_g_double_vartime_noalloc:
out:point
-> scalar1:felem -> q1:point
-> scalar2:felem -> q2:point
-> table2:lbuffer uint64 (32ul *! 12ul) ->
Stack unit
(requires fun h ->
live h out /\ live h scalar1 /\ live h q1 /\
live h scalar2 /\ live h q2 /\ live h table2 /\
eq_or_disjoint q1 q2 /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out scalar1 /\ disjoint out scalar2 /\ disjoint out table2 /\
as_nat h scalar1 < S.order /\ as_nat h scalar2 < S.order /\
point_inv h q1 /\ from_mont_point (as_point_nat h q1) == S.base_point /\
point_inv h q2 /\ table_inv_w5 (as_seq h q2) (as_seq h table2))
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
refl (as_seq h1 out) ==
S.to_aff_point (S.point_mul_double_g
(as_nat h0 scalar1) (as_nat h0 scalar2) (from_mont_point (as_point_nat h0 q2))))
let point_mul_g_double_vartime_noalloc out scalar1 q1 scalar2 q2 table2 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
[@inline_let] let bLen = 4ul in
[@inline_let] let bBits = 256ul in
assert_norm (pow2 (v l) == v table_len);
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w5 precomp_basepoint_table_lseq_w5;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w5 ();
assert (table_inv_w5 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w5));
assert (table_inv_w5 (as_seq h1 q2) (as_seq h1 table2));
ME.mk_lexp_double_fw_tables len ctx_len k l table_len
table_inv_w5 table_inv_w5
(BE.lprecomp_get_vartime len ctx_len k l table_len)
(BE.lprecomp_get_vartime len ctx_len k l table_len)
(null uint64) q1 bLen bBits scalar1 q2 scalar2
(to_const precomp_basepoint_table_w5) (to_const table2) out;
SE.exp_double_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 q1)) 256 (as_nat h0 scalar1)
(from_mont_point (as_point_nat h0 q2)) (as_nat h0 scalar2) 5 | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
res: Hacl.Impl.P256.Point.point ->
scalar1: Hacl.Impl.P256.Bignum.felem ->
scalar2: Hacl.Impl.P256.Bignum.felem ->
p: Hacl.Impl.P256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.P256.PointMul.point_mul_g_double_vartime_noalloc",
"Prims._assert",
"Hacl.Impl.P256.PointMul.table_inv_w5",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.PrecompTable.lprecomp_table",
"Lib.Buffer.null",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.mul",
"Lib.Buffer.create",
"Lib.IntTypes.u64",
"Lib.Buffer.lbuffer",
"Hacl.Impl.P256.Point.make_base_point",
"Hacl.Impl.P256.Point.create_point",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.pow2",
"Lib.IntTypes.v",
"FStar.UInt32.t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.P256.Group.mk_p256_concrete_ops",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let point_mul_double_g res scalar1 scalar2 q2 =
| push_frame ();
[@@ inline_let ]let len = 12ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_p256_concrete_ops in
[@@ inline_let ]let table_len = 32ul in
assert_norm (pow2 5 == v table_len);
let q1 = create_point () in
make_base_point q1;
let table2 = create (table_len *! len) (u64 0) in
PT.lprecomp_table len ctx_len k (null uint64) q2 table_len table2;
let h = ST.get () in
assert (table_inv_w5 (as_seq h q2) (as_seq h table2));
point_mul_g_double_vartime_noalloc res scalar1 q1 scalar2 q2 table2;
pop_frame () | false |
Hacl.Impl.P256.Sign.fst | Hacl.Impl.P256.Sign.ecdsa_sign_load | val ecdsa_sign_load (d_a k_q:felem) (private_key nonce:lbytes 32ul) : Stack uint64
(requires fun h ->
live h private_key /\ live h nonce /\ live h d_a /\ live h k_q /\
disjoint d_a k_q /\ disjoint d_a private_key /\ disjoint d_a nonce /\
disjoint k_q private_key /\ disjoint k_q nonce)
(ensures fun h0 m h1 -> modifies (loc d_a |+| loc k_q) h0 h1 /\
(let d_a_nat = BSeq.nat_from_bytes_be (as_seq h0 private_key) in
let k_nat = BSeq.nat_from_bytes_be (as_seq h0 nonce) in
let is_sk_valid = 0 < d_a_nat && d_a_nat < S.order in
let is_nonce_valid = 0 < k_nat && k_nat < S.order in
(v m = ones_v U64 \/ v m = 0) /\
(v m = ones_v U64) = (is_sk_valid && is_nonce_valid) /\
as_nat h1 d_a == (if is_sk_valid then d_a_nat else 1) /\
as_nat h1 k_q == (if is_nonce_valid then k_nat else 1))) | val ecdsa_sign_load (d_a k_q:felem) (private_key nonce:lbytes 32ul) : Stack uint64
(requires fun h ->
live h private_key /\ live h nonce /\ live h d_a /\ live h k_q /\
disjoint d_a k_q /\ disjoint d_a private_key /\ disjoint d_a nonce /\
disjoint k_q private_key /\ disjoint k_q nonce)
(ensures fun h0 m h1 -> modifies (loc d_a |+| loc k_q) h0 h1 /\
(let d_a_nat = BSeq.nat_from_bytes_be (as_seq h0 private_key) in
let k_nat = BSeq.nat_from_bytes_be (as_seq h0 nonce) in
let is_sk_valid = 0 < d_a_nat && d_a_nat < S.order in
let is_nonce_valid = 0 < k_nat && k_nat < S.order in
(v m = ones_v U64 \/ v m = 0) /\
(v m = ones_v U64) = (is_sk_valid && is_nonce_valid) /\
as_nat h1 d_a == (if is_sk_valid then d_a_nat else 1) /\
as_nat h1 k_q == (if is_nonce_valid then k_nat else 1))) | let ecdsa_sign_load d_a k_q private_key nonce =
let is_sk_valid = load_qelem_conditional d_a private_key in
let is_nonce_valid = load_qelem_conditional k_q nonce in
let m = is_sk_valid &. is_nonce_valid in
logand_lemma is_sk_valid is_nonce_valid;
m | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 108,
"start_col": 0,
"start_line": 103
} | module Hacl.Impl.P256.Sign
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.PointMul
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
module BB = Hacl.Bignum.Base
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --ifuel 0 --fuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
inline_for_extraction noextract
val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order))
let ecdsa_sign_r r k =
push_frame ();
let p = create_point () in
point_mul_g p k; // p = [k]G
to_aff_point_x r p;
qmod_short r r;
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_s (s k r d_a m:felem) : Stack unit
(requires fun h ->
live h s /\ live h m /\ live h d_a /\ live h k /\ live h r /\
disjoint s r /\ disjoint s k /\ disjoint r k /\
disjoint s d_a /\ disjoint r d_a /\ disjoint m s /\
0 < as_nat h k /\ as_nat h k < S.order /\
as_nat h r < S.order /\ as_nat h m < S.order /\
0 < as_nat h d_a /\ as_nat h d_a < S.order)
(ensures fun h0 _ h1 -> modifies (loc s |+| loc m) h0 h1 /\
(let kinv = S.qinv (as_nat h0 k) in
as_nat h1 s == S.qmul kinv (S.qadd (as_nat h0 m) (S.qmul (as_nat h0 r) (as_nat h0 d_a)))))
let ecdsa_sign_s s k r d_a m =
push_frame ();
let h0 = ST.get () in
let kinv = create_felem () in
QI.qinv kinv k;
let h1 = ST.get () in
assert (qmont_as_nat h1 kinv == S.qinv (qmont_as_nat h0 k));
SM.qmont_inv_lemma (as_nat h0 k);
assert (qmont_as_nat h1 kinv == S.qinv (as_nat h0 k) * SM.qmont_R % S.order);
qmul s r d_a; // s = r * d_a
let h2 = ST.get () in
assert (as_nat h2 s == (as_nat h0 r * as_nat h0 d_a * SM.qmont_R_inv) % S.order);
from_qmont m m;
let h3 = ST.get () in
assert (as_nat h3 m == as_nat h2 m * SM.qmont_R_inv % S.order);
qadd s m s; // s = z + s
let h4 = ST.get () in
assert (as_nat h4 s == (as_nat h3 m + as_nat h2 s) % S.order);
qmul s kinv s; // s = kinv * s
let h5 = ST.get () in
assert (as_nat h5 s == (as_nat h1 kinv * as_nat h4 s * SM.qmont_R_inv) % S.order);
SM.lemma_ecdsa_sign_s
(as_nat h0 k) (as_nat h1 kinv) (as_nat h0 r) (as_nat h0 d_a) (as_nat h0 m);
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_load (d_a k_q:felem) (private_key nonce:lbytes 32ul) : Stack uint64
(requires fun h ->
live h private_key /\ live h nonce /\ live h d_a /\ live h k_q /\
disjoint d_a k_q /\ disjoint d_a private_key /\ disjoint d_a nonce /\
disjoint k_q private_key /\ disjoint k_q nonce)
(ensures fun h0 m h1 -> modifies (loc d_a |+| loc k_q) h0 h1 /\
(let d_a_nat = BSeq.nat_from_bytes_be (as_seq h0 private_key) in
let k_nat = BSeq.nat_from_bytes_be (as_seq h0 nonce) in
let is_sk_valid = 0 < d_a_nat && d_a_nat < S.order in
let is_nonce_valid = 0 < k_nat && k_nat < S.order in
(v m = ones_v U64 \/ v m = 0) /\
(v m = ones_v U64) = (is_sk_valid && is_nonce_valid) /\
as_nat h1 d_a == (if is_sk_valid then d_a_nat else 1) /\
as_nat h1 k_q == (if is_nonce_valid then k_nat else 1))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
d_a: Hacl.Impl.P256.Bignum.felem ->
k_q: Hacl.Impl.P256.Bignum.felem ->
private_key: Hacl.Impl.P256.Sign.lbytes 32ul ->
nonce: Hacl.Impl.P256.Sign.lbytes 32ul
-> FStar.HyperStack.ST.Stack Lib.IntTypes.uint64 | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Sign.lbytes",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.uint64",
"Hacl.Impl.P256.Scalar.load_qelem_conditional"
] | [] | false | true | false | false | false | let ecdsa_sign_load d_a k_q private_key nonce =
| let is_sk_valid = load_qelem_conditional d_a private_key in
let is_nonce_valid = load_qelem_conditional k_q nonce in
let m = is_sk_valid &. is_nonce_valid in
logand_lemma is_sk_valid is_nonce_valid;
m | false |
Hacl.Impl.P256.Sign.fst | Hacl.Impl.P256.Sign.check_signature | val check_signature: are_sk_nonce_valid:uint64 -> r_q:felem -> s_q:felem -> Stack bool
(requires fun h ->
live h r_q /\ live h s_q /\ disjoint r_q s_q /\
(v are_sk_nonce_valid = ones_v U64 \/ v are_sk_nonce_valid = 0))
(ensures fun h0 res h1 -> modifies0 h0 h1 /\
res == ((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q))) | val check_signature: are_sk_nonce_valid:uint64 -> r_q:felem -> s_q:felem -> Stack bool
(requires fun h ->
live h r_q /\ live h s_q /\ disjoint r_q s_q /\
(v are_sk_nonce_valid = ones_v U64 \/ v are_sk_nonce_valid = 0))
(ensures fun h0 res h1 -> modifies0 h0 h1 /\
res == ((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q))) | let check_signature are_sk_nonce_valid r_q s_q =
let h0 = ST.get () in
let is_r_zero = bn_is_zero_mask4 r_q in
let is_s_zero = bn_is_zero_mask4 s_q in
[@inline_let] let m0 = lognot is_r_zero in
[@inline_let] let m1 = lognot is_s_zero in
[@inline_let] let m2 = m0 &. m1 in
lognot_lemma is_r_zero;
lognot_lemma is_s_zero;
logand_lemma m0 m1;
let m = are_sk_nonce_valid &. m2 in
logand_lemma are_sk_nonce_valid m2;
assert ((v m = ones_v U64) <==>
((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q)));
BB.unsafe_bool_of_limb m | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 133,
"start_col": 0,
"start_line": 119
} | module Hacl.Impl.P256.Sign
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.PointMul
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
module BB = Hacl.Bignum.Base
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --ifuel 0 --fuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
inline_for_extraction noextract
val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order))
let ecdsa_sign_r r k =
push_frame ();
let p = create_point () in
point_mul_g p k; // p = [k]G
to_aff_point_x r p;
qmod_short r r;
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_s (s k r d_a m:felem) : Stack unit
(requires fun h ->
live h s /\ live h m /\ live h d_a /\ live h k /\ live h r /\
disjoint s r /\ disjoint s k /\ disjoint r k /\
disjoint s d_a /\ disjoint r d_a /\ disjoint m s /\
0 < as_nat h k /\ as_nat h k < S.order /\
as_nat h r < S.order /\ as_nat h m < S.order /\
0 < as_nat h d_a /\ as_nat h d_a < S.order)
(ensures fun h0 _ h1 -> modifies (loc s |+| loc m) h0 h1 /\
(let kinv = S.qinv (as_nat h0 k) in
as_nat h1 s == S.qmul kinv (S.qadd (as_nat h0 m) (S.qmul (as_nat h0 r) (as_nat h0 d_a)))))
let ecdsa_sign_s s k r d_a m =
push_frame ();
let h0 = ST.get () in
let kinv = create_felem () in
QI.qinv kinv k;
let h1 = ST.get () in
assert (qmont_as_nat h1 kinv == S.qinv (qmont_as_nat h0 k));
SM.qmont_inv_lemma (as_nat h0 k);
assert (qmont_as_nat h1 kinv == S.qinv (as_nat h0 k) * SM.qmont_R % S.order);
qmul s r d_a; // s = r * d_a
let h2 = ST.get () in
assert (as_nat h2 s == (as_nat h0 r * as_nat h0 d_a * SM.qmont_R_inv) % S.order);
from_qmont m m;
let h3 = ST.get () in
assert (as_nat h3 m == as_nat h2 m * SM.qmont_R_inv % S.order);
qadd s m s; // s = z + s
let h4 = ST.get () in
assert (as_nat h4 s == (as_nat h3 m + as_nat h2 s) % S.order);
qmul s kinv s; // s = kinv * s
let h5 = ST.get () in
assert (as_nat h5 s == (as_nat h1 kinv * as_nat h4 s * SM.qmont_R_inv) % S.order);
SM.lemma_ecdsa_sign_s
(as_nat h0 k) (as_nat h1 kinv) (as_nat h0 r) (as_nat h0 d_a) (as_nat h0 m);
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_load (d_a k_q:felem) (private_key nonce:lbytes 32ul) : Stack uint64
(requires fun h ->
live h private_key /\ live h nonce /\ live h d_a /\ live h k_q /\
disjoint d_a k_q /\ disjoint d_a private_key /\ disjoint d_a nonce /\
disjoint k_q private_key /\ disjoint k_q nonce)
(ensures fun h0 m h1 -> modifies (loc d_a |+| loc k_q) h0 h1 /\
(let d_a_nat = BSeq.nat_from_bytes_be (as_seq h0 private_key) in
let k_nat = BSeq.nat_from_bytes_be (as_seq h0 nonce) in
let is_sk_valid = 0 < d_a_nat && d_a_nat < S.order in
let is_nonce_valid = 0 < k_nat && k_nat < S.order in
(v m = ones_v U64 \/ v m = 0) /\
(v m = ones_v U64) = (is_sk_valid && is_nonce_valid) /\
as_nat h1 d_a == (if is_sk_valid then d_a_nat else 1) /\
as_nat h1 k_q == (if is_nonce_valid then k_nat else 1)))
let ecdsa_sign_load d_a k_q private_key nonce =
let is_sk_valid = load_qelem_conditional d_a private_key in
let is_nonce_valid = load_qelem_conditional k_q nonce in
let m = is_sk_valid &. is_nonce_valid in
logand_lemma is_sk_valid is_nonce_valid;
m
inline_for_extraction noextract
val check_signature: are_sk_nonce_valid:uint64 -> r_q:felem -> s_q:felem -> Stack bool
(requires fun h ->
live h r_q /\ live h s_q /\ disjoint r_q s_q /\
(v are_sk_nonce_valid = ones_v U64 \/ v are_sk_nonce_valid = 0))
(ensures fun h0 res h1 -> modifies0 h0 h1 /\
res == ((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
are_sk_nonce_valid: Lib.IntTypes.uint64 ->
r_q: Hacl.Impl.P256.Bignum.felem ->
s_q: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntTypes.uint64",
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Lib.IntTypes.U64",
"Prims.unit",
"Prims._assert",
"Prims.l_iff",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.ones_v",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Hacl.Impl.P256.Bignum.as_nat",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.lognot_lemma",
"Lib.IntTypes.lognot",
"Prims.bool",
"Hacl.Impl.P256.Bignum.bn_is_zero_mask4",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let check_signature are_sk_nonce_valid r_q s_q =
| let h0 = ST.get () in
let is_r_zero = bn_is_zero_mask4 r_q in
let is_s_zero = bn_is_zero_mask4 s_q in
[@@ inline_let ]let m0 = lognot is_r_zero in
[@@ inline_let ]let m1 = lognot is_s_zero in
[@@ inline_let ]let m2 = m0 &. m1 in
lognot_lemma is_r_zero;
lognot_lemma is_s_zero;
logand_lemma m0 m1;
let m = are_sk_nonce_valid &. m2 in
logand_lemma are_sk_nonce_valid m2;
assert ((v m = ones_v U64) <==>
((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q)));
BB.unsafe_bool_of_limb m | false |
Hacl.Impl.P256.Sign.fst | Hacl.Impl.P256.Sign.ecdsa_sign_r | val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order)) | val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order)) | let ecdsa_sign_r r k =
push_frame ();
let p = create_point () in
point_mul_g p k; // p = [k]G
to_aff_point_x r p;
qmod_short r r;
pop_frame () | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 43,
"start_col": 0,
"start_line": 37
} | module Hacl.Impl.P256.Sign
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.PointMul
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
module BB = Hacl.Bignum.Base
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --ifuel 0 --fuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
inline_for_extraction noextract
val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order)) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Hacl.Impl.P256.Bignum.felem -> k: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.P256.Scalar.qmod_short",
"Hacl.Impl.P256.Point.to_aff_point_x",
"Hacl.Impl.P256.PointMul.point_mul_g",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Point.create_point",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let ecdsa_sign_r r k =
| push_frame ();
let p = create_point () in
point_mul_g p k;
to_aff_point_x r p;
qmod_short r r;
pop_frame () | false |
Hacl.Impl.P256.Sign.fst | Hacl.Impl.P256.Sign.ecdsa_sign_s | val ecdsa_sign_s (s k r d_a m:felem) : Stack unit
(requires fun h ->
live h s /\ live h m /\ live h d_a /\ live h k /\ live h r /\
disjoint s r /\ disjoint s k /\ disjoint r k /\
disjoint s d_a /\ disjoint r d_a /\ disjoint m s /\
0 < as_nat h k /\ as_nat h k < S.order /\
as_nat h r < S.order /\ as_nat h m < S.order /\
0 < as_nat h d_a /\ as_nat h d_a < S.order)
(ensures fun h0 _ h1 -> modifies (loc s |+| loc m) h0 h1 /\
(let kinv = S.qinv (as_nat h0 k) in
as_nat h1 s == S.qmul kinv (S.qadd (as_nat h0 m) (S.qmul (as_nat h0 r) (as_nat h0 d_a))))) | val ecdsa_sign_s (s k r d_a m:felem) : Stack unit
(requires fun h ->
live h s /\ live h m /\ live h d_a /\ live h k /\ live h r /\
disjoint s r /\ disjoint s k /\ disjoint r k /\
disjoint s d_a /\ disjoint r d_a /\ disjoint m s /\
0 < as_nat h k /\ as_nat h k < S.order /\
as_nat h r < S.order /\ as_nat h m < S.order /\
0 < as_nat h d_a /\ as_nat h d_a < S.order)
(ensures fun h0 _ h1 -> modifies (loc s |+| loc m) h0 h1 /\
(let kinv = S.qinv (as_nat h0 k) in
as_nat h1 s == S.qmul kinv (S.qadd (as_nat h0 m) (S.qmul (as_nat h0 r) (as_nat h0 d_a))))) | let ecdsa_sign_s s k r d_a m =
push_frame ();
let h0 = ST.get () in
let kinv = create_felem () in
QI.qinv kinv k;
let h1 = ST.get () in
assert (qmont_as_nat h1 kinv == S.qinv (qmont_as_nat h0 k));
SM.qmont_inv_lemma (as_nat h0 k);
assert (qmont_as_nat h1 kinv == S.qinv (as_nat h0 k) * SM.qmont_R % S.order);
qmul s r d_a; // s = r * d_a
let h2 = ST.get () in
assert (as_nat h2 s == (as_nat h0 r * as_nat h0 d_a * SM.qmont_R_inv) % S.order);
from_qmont m m;
let h3 = ST.get () in
assert (as_nat h3 m == as_nat h2 m * SM.qmont_R_inv % S.order);
qadd s m s; // s = z + s
let h4 = ST.get () in
assert (as_nat h4 s == (as_nat h3 m + as_nat h2 s) % S.order);
qmul s kinv s; // s = kinv * s
let h5 = ST.get () in
assert (as_nat h5 s == (as_nat h1 kinv * as_nat h4 s * SM.qmont_R_inv) % S.order);
SM.lemma_ecdsa_sign_s
(as_nat h0 k) (as_nat h1 kinv) (as_nat h0 r) (as_nat h0 d_a) (as_nat h0 m);
pop_frame () | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 84,
"start_col": 0,
"start_line": 60
} | module Hacl.Impl.P256.Sign
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.PointMul
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
module BB = Hacl.Bignum.Base
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --ifuel 0 --fuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
inline_for_extraction noextract
val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order))
let ecdsa_sign_r r k =
push_frame ();
let p = create_point () in
point_mul_g p k; // p = [k]G
to_aff_point_x r p;
qmod_short r r;
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_s (s k r d_a m:felem) : Stack unit
(requires fun h ->
live h s /\ live h m /\ live h d_a /\ live h k /\ live h r /\
disjoint s r /\ disjoint s k /\ disjoint r k /\
disjoint s d_a /\ disjoint r d_a /\ disjoint m s /\
0 < as_nat h k /\ as_nat h k < S.order /\
as_nat h r < S.order /\ as_nat h m < S.order /\
0 < as_nat h d_a /\ as_nat h d_a < S.order)
(ensures fun h0 _ h1 -> modifies (loc s |+| loc m) h0 h1 /\
(let kinv = S.qinv (as_nat h0 k) in
as_nat h1 s == S.qmul kinv (S.qadd (as_nat h0 m) (S.qmul (as_nat h0 r) (as_nat h0 d_a))))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: Hacl.Impl.P256.Bignum.felem ->
k: Hacl.Impl.P256.Bignum.felem ->
r: Hacl.Impl.P256.Bignum.felem ->
d_a: Hacl.Impl.P256.Bignum.felem ->
m: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Spec.P256.Montgomery.lemma_ecdsa_sign_s",
"Hacl.Impl.P256.Bignum.as_nat",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.P256.Montgomery.qmont_R_inv",
"Spec.P256.PointOps.order",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.P256.Scalar.qmul",
"Prims.op_Addition",
"Hacl.Impl.P256.Scalar.qadd",
"Hacl.Impl.P256.Scalar.from_qmont",
"Hacl.Impl.P256.Scalar.qmont_as_nat",
"Spec.P256.PointOps.qinv",
"Hacl.Spec.P256.Montgomery.qmont_R",
"Hacl.Spec.P256.Montgomery.qmont_inv_lemma",
"Spec.P256.PointOps.qelem",
"Hacl.Impl.P256.Qinv.qinv",
"Hacl.Impl.P256.Bignum.create_felem",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let ecdsa_sign_s s k r d_a m =
| push_frame ();
let h0 = ST.get () in
let kinv = create_felem () in
QI.qinv kinv k;
let h1 = ST.get () in
assert (qmont_as_nat h1 kinv == S.qinv (qmont_as_nat h0 k));
SM.qmont_inv_lemma (as_nat h0 k);
assert (qmont_as_nat h1 kinv == S.qinv (as_nat h0 k) * SM.qmont_R % S.order);
qmul s r d_a;
let h2 = ST.get () in
assert (as_nat h2 s == ((as_nat h0 r * as_nat h0 d_a) * SM.qmont_R_inv) % S.order);
from_qmont m m;
let h3 = ST.get () in
assert (as_nat h3 m == as_nat h2 m * SM.qmont_R_inv % S.order);
qadd s m s;
let h4 = ST.get () in
assert (as_nat h4 s == (as_nat h3 m + as_nat h2 s) % S.order);
qmul s kinv s;
let h5 = ST.get () in
assert (as_nat h5 s == ((as_nat h1 kinv * as_nat h4 s) * SM.qmont_R_inv) % S.order);
SM.lemma_ecdsa_sign_s (as_nat h0 k) (as_nat h1 kinv) (as_nat h0 r) (as_nat h0 d_a) (as_nat h0 m);
pop_frame () | false |
Hacl.Impl.P256.PointMul.fst | Hacl.Impl.P256.PointMul.point_mul_g | val point_mul_g: res:point -> scalar:felem -> Stack unit
(requires fun h ->
live h res /\ live h scalar /\ disjoint res scalar /\
as_nat h scalar < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
point_inv h1 res /\
S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul_g (as_nat h0 scalar))) | val point_mul_g: res:point -> scalar:felem -> Stack unit
(requires fun h ->
live h res /\ live h scalar /\ disjoint res scalar /\
as_nat h scalar < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
point_inv h1 res /\
S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul_g (as_nat h0 scalar))) | let point_mul_g res scalar =
push_frame ();
let h0 = ST.get () in
let q1 = create_point () in
make_base_point q1;
let q2 = mk_proj_g_pow2_64 () in
let q3 = mk_proj_g_pow2_128 () in
let q4 = mk_proj_g_pow2_192 () in
proj_g_pow2_64_lseq_lemma ();
proj_g_pow2_128_lseq_lemma ();
proj_g_pow2_192_lseq_lemma ();
point_mul_g_noalloc res scalar q1 q2 q3 q4;
LowStar.Ignore.ignore q1;
LowStar.Ignore.ignore q2;
LowStar.Ignore.ignore q3;
LowStar.Ignore.ignore q4;
lemma_exp_four_fw_local (as_seq h0 scalar);
pop_frame () | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 181,
"start_col": 0,
"start_line": 164
} | module Hacl.Impl.P256.PointMul
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
open Hacl.Impl.P256.Point
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Spec.Bignum.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
include Hacl.Impl.P256.Group
include Hacl.P256.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 12ul 16ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 12ul 32ul =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len
[@CInline]
let point_mul res scalar p =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_p256_concrete_ops
(from_mont_point (as_point_nat h0 p)) 256 (as_nat h0 scalar) 4;
BE.lexp_fw_consttime 12ul 0ul mk_p256_concrete_ops 4ul (null uint64) p 4ul 256ul scalar res
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 12ul 0ul mk_p256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 12ul 0ul mk_p256_concrete_ops 4ul 16ul)
[@CInline]
let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp
inline_for_extraction noextract
val point_mul_g_noalloc: out:point -> scalar:felem
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h scalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out scalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
as_nat h scalar < S.order /\
point_inv h q1 /\ refl (as_seq h q1) == g_aff /\
point_inv h q2 /\ refl (as_seq h q2) == g_pow2_64 /\
point_inv h q3 /\ refl (as_seq h q3) == g_pow2_128 /\
point_inv h q4 /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (as_nat h0 scalar) in
S.to_aff_point (from_mont_point (as_point_nat h1 out)) ==
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4))
let point_mul_g_noalloc out scalar q1 q2 q3 q4 =
[@inline_let] let len = 12ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_p256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
[@inline_let] let bLen = 1ul in
[@inline_let] let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub scalar 0ul 1ul in
let r2 = sub scalar 1ul 1ul in
let r3 = sub scalar 2ul 1ul in
let r4 = sub scalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 scalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len
table_inv_w4 table_inv_w4 table_inv_w4 table_inv_w4
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
(null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4)
(to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4)
(to_const precomp_g_pow2_192_table_w4)
out
val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.order} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_p256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b)))
let lemma_exp_four_fw_local b =
let cm = S.mk_p256_comm_monoid in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.lemma_point_mul_base_precomp4 cm g_aff (BD.bn_v b);
assert (res == LE.pow cm g_aff (BD.bn_v b));
SE.exp_fw_lemma S.mk_p256_concrete_ops S.base_point 256 (BD.bn_v b) 4;
LE.exp_fw_lemma cm g_aff 256 (BD.bn_v b) 4;
assert (S.to_aff_point (S.point_mul_g (BD.bn_v b)) == LE.pow cm g_aff (BD.bn_v b)) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.P256.PrecompTable.fsti.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Group.fst.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.P256.PointMul.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | res: Hacl.Impl.P256.Point.point -> scalar: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.P256.PointMul.lemma_exp_four_fw_local",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size",
"LowStar.Ignore.ignore",
"Lib.Buffer.lbuffer",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.PointMul.point_mul_g_noalloc",
"Hacl.P256.PrecompTable.proj_g_pow2_192_lseq_lemma",
"Hacl.P256.PrecompTable.proj_g_pow2_128_lseq_lemma",
"Hacl.P256.PrecompTable.proj_g_pow2_64_lseq_lemma",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Hacl.P256.PrecompTable.mk_proj_g_pow2_192",
"Hacl.P256.PrecompTable.mk_proj_g_pow2_128",
"Hacl.P256.PrecompTable.mk_proj_g_pow2_64",
"Hacl.Impl.P256.Point.make_base_point",
"Hacl.Impl.P256.Point.create_point",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let point_mul_g res scalar =
| push_frame ();
let h0 = ST.get () in
let q1 = create_point () in
make_base_point q1;
let q2 = mk_proj_g_pow2_64 () in
let q3 = mk_proj_g_pow2_128 () in
let q4 = mk_proj_g_pow2_192 () in
proj_g_pow2_64_lseq_lemma ();
proj_g_pow2_128_lseq_lemma ();
proj_g_pow2_192_lseq_lemma ();
point_mul_g_noalloc res scalar q1 q2 q3 q4;
LowStar.Ignore.ignore q1;
LowStar.Ignore.ignore q2;
LowStar.Ignore.ignore q3;
LowStar.Ignore.ignore q4;
lemma_exp_four_fw_local (as_seq h0 scalar);
pop_frame () | false |
Hacl.Impl.P256.Sign.fst | Hacl.Impl.P256.Sign.ecdsa_sign_msg_as_qelem | val ecdsa_sign_msg_as_qelem:
signature:lbuffer uint8 64ul
-> m_q:felem
-> private_key:lbuffer uint8 32ul
-> nonce:lbuffer uint8 32ul ->
Stack bool
(requires fun h ->
live h signature /\ live h m_q /\ live h private_key /\ live h nonce /\
disjoint signature m_q /\ disjoint signature private_key /\ disjoint signature nonce /\
disjoint m_q private_key /\ disjoint m_q nonce /\
as_nat h m_q < S.order)
(ensures fun h0 flag h1 -> modifies (loc signature |+| loc m_q) h0 h1 /\
(let sgnt = S.ecdsa_sign_msg_as_qelem
(as_nat h0 m_q) (as_seq h0 private_key) (as_seq h0 nonce) in
(flag <==> Some? sgnt) /\ (flag ==> (as_seq h1 signature == Some?.v sgnt)))) | val ecdsa_sign_msg_as_qelem:
signature:lbuffer uint8 64ul
-> m_q:felem
-> private_key:lbuffer uint8 32ul
-> nonce:lbuffer uint8 32ul ->
Stack bool
(requires fun h ->
live h signature /\ live h m_q /\ live h private_key /\ live h nonce /\
disjoint signature m_q /\ disjoint signature private_key /\ disjoint signature nonce /\
disjoint m_q private_key /\ disjoint m_q nonce /\
as_nat h m_q < S.order)
(ensures fun h0 flag h1 -> modifies (loc signature |+| loc m_q) h0 h1 /\
(let sgnt = S.ecdsa_sign_msg_as_qelem
(as_nat h0 m_q) (as_seq h0 private_key) (as_seq h0 nonce) in
(flag <==> Some? sgnt) /\ (flag ==> (as_seq h1 signature == Some?.v sgnt)))) | let ecdsa_sign_msg_as_qelem signature m_q private_key nonce =
push_frame ();
let rsdk_q = create 16ul (u64 0) in
let r_q = sub rsdk_q 0ul 4ul in
let s_q = sub rsdk_q 4ul 4ul in
let d_a = sub rsdk_q 8ul 4ul in
let k_q = sub rsdk_q 12ul 4ul in
let are_sk_nonce_valid = ecdsa_sign_load d_a k_q private_key nonce in
ecdsa_sign_r r_q k_q;
ecdsa_sign_s s_q k_q r_q d_a m_q;
bn2_to_bytes_be4 signature r_q s_q;
let res = check_signature are_sk_nonce_valid r_q s_q in
pop_frame ();
res | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 166,
"start_col": 0,
"start_line": 153
} | module Hacl.Impl.P256.Sign
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.PointMul
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
module BB = Hacl.Bignum.Base
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --ifuel 0 --fuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
inline_for_extraction noextract
val ecdsa_sign_r (r k:felem) : Stack unit
(requires fun h ->
live h r /\ live h k /\ disjoint r k /\
as_nat h k < S.order)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
(let x, _ = S.to_aff_point (S.point_mul_g (as_nat h0 k)) in
as_nat h1 r == x % S.order))
let ecdsa_sign_r r k =
push_frame ();
let p = create_point () in
point_mul_g p k; // p = [k]G
to_aff_point_x r p;
qmod_short r r;
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_s (s k r d_a m:felem) : Stack unit
(requires fun h ->
live h s /\ live h m /\ live h d_a /\ live h k /\ live h r /\
disjoint s r /\ disjoint s k /\ disjoint r k /\
disjoint s d_a /\ disjoint r d_a /\ disjoint m s /\
0 < as_nat h k /\ as_nat h k < S.order /\
as_nat h r < S.order /\ as_nat h m < S.order /\
0 < as_nat h d_a /\ as_nat h d_a < S.order)
(ensures fun h0 _ h1 -> modifies (loc s |+| loc m) h0 h1 /\
(let kinv = S.qinv (as_nat h0 k) in
as_nat h1 s == S.qmul kinv (S.qadd (as_nat h0 m) (S.qmul (as_nat h0 r) (as_nat h0 d_a)))))
let ecdsa_sign_s s k r d_a m =
push_frame ();
let h0 = ST.get () in
let kinv = create_felem () in
QI.qinv kinv k;
let h1 = ST.get () in
assert (qmont_as_nat h1 kinv == S.qinv (qmont_as_nat h0 k));
SM.qmont_inv_lemma (as_nat h0 k);
assert (qmont_as_nat h1 kinv == S.qinv (as_nat h0 k) * SM.qmont_R % S.order);
qmul s r d_a; // s = r * d_a
let h2 = ST.get () in
assert (as_nat h2 s == (as_nat h0 r * as_nat h0 d_a * SM.qmont_R_inv) % S.order);
from_qmont m m;
let h3 = ST.get () in
assert (as_nat h3 m == as_nat h2 m * SM.qmont_R_inv % S.order);
qadd s m s; // s = z + s
let h4 = ST.get () in
assert (as_nat h4 s == (as_nat h3 m + as_nat h2 s) % S.order);
qmul s kinv s; // s = kinv * s
let h5 = ST.get () in
assert (as_nat h5 s == (as_nat h1 kinv * as_nat h4 s * SM.qmont_R_inv) % S.order);
SM.lemma_ecdsa_sign_s
(as_nat h0 k) (as_nat h1 kinv) (as_nat h0 r) (as_nat h0 d_a) (as_nat h0 m);
pop_frame ()
inline_for_extraction noextract
val ecdsa_sign_load (d_a k_q:felem) (private_key nonce:lbytes 32ul) : Stack uint64
(requires fun h ->
live h private_key /\ live h nonce /\ live h d_a /\ live h k_q /\
disjoint d_a k_q /\ disjoint d_a private_key /\ disjoint d_a nonce /\
disjoint k_q private_key /\ disjoint k_q nonce)
(ensures fun h0 m h1 -> modifies (loc d_a |+| loc k_q) h0 h1 /\
(let d_a_nat = BSeq.nat_from_bytes_be (as_seq h0 private_key) in
let k_nat = BSeq.nat_from_bytes_be (as_seq h0 nonce) in
let is_sk_valid = 0 < d_a_nat && d_a_nat < S.order in
let is_nonce_valid = 0 < k_nat && k_nat < S.order in
(v m = ones_v U64 \/ v m = 0) /\
(v m = ones_v U64) = (is_sk_valid && is_nonce_valid) /\
as_nat h1 d_a == (if is_sk_valid then d_a_nat else 1) /\
as_nat h1 k_q == (if is_nonce_valid then k_nat else 1)))
let ecdsa_sign_load d_a k_q private_key nonce =
let is_sk_valid = load_qelem_conditional d_a private_key in
let is_nonce_valid = load_qelem_conditional k_q nonce in
let m = is_sk_valid &. is_nonce_valid in
logand_lemma is_sk_valid is_nonce_valid;
m
inline_for_extraction noextract
val check_signature: are_sk_nonce_valid:uint64 -> r_q:felem -> s_q:felem -> Stack bool
(requires fun h ->
live h r_q /\ live h s_q /\ disjoint r_q s_q /\
(v are_sk_nonce_valid = ones_v U64 \/ v are_sk_nonce_valid = 0))
(ensures fun h0 res h1 -> modifies0 h0 h1 /\
res == ((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q)))
let check_signature are_sk_nonce_valid r_q s_q =
let h0 = ST.get () in
let is_r_zero = bn_is_zero_mask4 r_q in
let is_s_zero = bn_is_zero_mask4 s_q in
[@inline_let] let m0 = lognot is_r_zero in
[@inline_let] let m1 = lognot is_s_zero in
[@inline_let] let m2 = m0 &. m1 in
lognot_lemma is_r_zero;
lognot_lemma is_s_zero;
logand_lemma m0 m1;
let m = are_sk_nonce_valid &. m2 in
logand_lemma are_sk_nonce_valid m2;
assert ((v m = ones_v U64) <==>
((v are_sk_nonce_valid = ones_v U64) && (0 < as_nat h0 r_q) && (0 < as_nat h0 s_q)));
BB.unsafe_bool_of_limb m
val ecdsa_sign_msg_as_qelem:
signature:lbuffer uint8 64ul
-> m_q:felem
-> private_key:lbuffer uint8 32ul
-> nonce:lbuffer uint8 32ul ->
Stack bool
(requires fun h ->
live h signature /\ live h m_q /\ live h private_key /\ live h nonce /\
disjoint signature m_q /\ disjoint signature private_key /\ disjoint signature nonce /\
disjoint m_q private_key /\ disjoint m_q nonce /\
as_nat h m_q < S.order)
(ensures fun h0 flag h1 -> modifies (loc signature |+| loc m_q) h0 h1 /\
(let sgnt = S.ecdsa_sign_msg_as_qelem
(as_nat h0 m_q) (as_seq h0 private_key) (as_seq h0 nonce) in
(flag <==> Some? sgnt) /\ (flag ==> (as_seq h1 signature == Some?.v sgnt)))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul ->
m_q: Hacl.Impl.P256.Bignum.felem ->
private_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
nonce: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Bignum.felem",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.P256.Sign.check_signature",
"Hacl.Impl.P256.Bignum.bn2_to_bytes_be4",
"Hacl.Impl.P256.Sign.ecdsa_sign_s",
"Hacl.Impl.P256.Sign.ecdsa_sign_r",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Impl.P256.Sign.ecdsa_sign_load",
"Lib.IntTypes.uint64",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"Lib.Buffer.create",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let ecdsa_sign_msg_as_qelem signature m_q private_key nonce =
| push_frame ();
let rsdk_q = create 16ul (u64 0) in
let r_q = sub rsdk_q 0ul 4ul in
let s_q = sub rsdk_q 4ul 4ul in
let d_a = sub rsdk_q 8ul 4ul in
let k_q = sub rsdk_q 12ul 4ul in
let are_sk_nonce_valid = ecdsa_sign_load d_a k_q private_key nonce in
ecdsa_sign_r r_q k_q;
ecdsa_sign_s s_q k_q r_q d_a m_q;
bn2_to_bytes_be4 signature r_q s_q;
let res = check_signature are_sk_nonce_valid r_q s_q in
pop_frame ();
res | false |
Hacl.Impl.Ed25519.PointAdd.fst | Hacl.Impl.Ed25519.PointAdd.point_add_step_2 | val point_add_step_2: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q /\
F51.mul_inv_t h (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h (gsub tmp 15ul 5ul))
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let z1 = F51.fevalh h0 (gsub p 10ul 5ul) in
let t1 = F51.fevalh h0 (gsub p 15ul 5ul) in
let z2 = F51.fevalh h0 (gsub q 10ul 5ul) in
let t2 = F51.fevalh h0 (gsub q 15ul 5ul) in
let a = F51.fevalh h0 (gsub tmp 10ul 5ul) in
let b = F51.fevalh h0 (gsub tmp 15ul 5ul) in
let c = (2 `SC.fmul` Spec.Ed25519.d `SC.fmul` t1) `SC.fmul` t2 in
let d = (2 `SC.fmul` z1) `SC.fmul` z2 in
let e = b `SC.fsub` a in
let f = d `SC.fsub` c in
let g = d `SC.fadd` c in
let h = b `SC.fadd` a in
F51.felem_fits h1 (gsub tmp 20ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 25ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 0ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 5ul 5ul) (9, 10, 9, 9, 9) /\
F51.fevalh h1 (gsub tmp 20ul 5ul) == e /\
F51.fevalh h1 (gsub tmp 25ul 5ul) == f /\
F51.fevalh h1 (gsub tmp 0ul 5ul) == g /\
F51.fevalh h1 (gsub tmp 5ul 5ul) == h)) | val point_add_step_2: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q /\
F51.mul_inv_t h (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h (gsub tmp 15ul 5ul))
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let z1 = F51.fevalh h0 (gsub p 10ul 5ul) in
let t1 = F51.fevalh h0 (gsub p 15ul 5ul) in
let z2 = F51.fevalh h0 (gsub q 10ul 5ul) in
let t2 = F51.fevalh h0 (gsub q 15ul 5ul) in
let a = F51.fevalh h0 (gsub tmp 10ul 5ul) in
let b = F51.fevalh h0 (gsub tmp 15ul 5ul) in
let c = (2 `SC.fmul` Spec.Ed25519.d `SC.fmul` t1) `SC.fmul` t2 in
let d = (2 `SC.fmul` z1) `SC.fmul` z2 in
let e = b `SC.fsub` a in
let f = d `SC.fsub` c in
let g = d `SC.fadd` c in
let h = b `SC.fadd` a in
F51.felem_fits h1 (gsub tmp 20ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 25ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 0ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 5ul 5ul) (9, 10, 9, 9, 9) /\
F51.fevalh h1 (gsub tmp 20ul 5ul) == e /\
F51.fevalh h1 (gsub tmp 25ul 5ul) == f /\
F51.fevalh h1 (gsub tmp 0ul 5ul) == g /\
F51.fevalh h1 (gsub tmp 5ul 5ul) == h)) | let point_add_step_2 p q tmp =
let tmp1 = sub tmp 0ul 5ul in // g
let tmp2 = sub tmp 5ul 5ul in // h
let tmp3 = sub tmp 10ul 5ul in // a
let tmp4 = sub tmp 15ul 5ul in // b
let tmp5 = sub tmp 20ul 5ul in // e
let tmp6 = sub tmp 25ul 5ul in // f
let z1 = getz p in
let t1 = gett p in
let z2 = getz q in
let t2 = gett q in
times_2d tmp1 t1; // tmp1 = 2 * d * t1
fmul tmp1 tmp1 t2; // tmp1 = tmp1 * t2 = c
times_2 tmp2 z1; // tmp2 = 2 * z1
fmul tmp2 tmp2 z2; // tmp2 = tmp2 * z2 = d
fdifference tmp5 tmp4 tmp3; // tmp5 = e = b - a = tmp4 - tmp3
fdifference tmp6 tmp2 tmp1; // tmp6 = f = d - c = tmp2 - tmp1
fsum tmp1 tmp2 tmp1; // tmp1 = g = d + c = tmp2 + tmp1
fsum tmp2 tmp4 tmp3 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 101,
"start_col": 0,
"start_line": 81
} | module Hacl.Impl.Ed25519.PointAdd
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val point_add_step_1: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let x1 = F51.fevalh h0 (gsub p 0ul 5ul) in
let y1 = F51.fevalh h0 (gsub p 5ul 5ul) in
let x2 = F51.fevalh h0 (gsub q 0ul 5ul) in
let y2 = F51.fevalh h0 (gsub q 5ul 5ul) in
let a = (y1 `SC.fsub` x1) `SC.fmul` (y2 `SC.fsub` x2) in
let b = (y1 `SC.fadd` x1) `SC.fmul` (y2 `SC.fadd` x2) in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h1 (gsub tmp 15ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == a /\
F51.fevalh h1 (gsub tmp 15ul 5ul) == b))
let point_add_step_1 p q tmp =
let tmp1 = sub tmp 0ul 5ul in
let tmp2 = sub tmp 5ul 5ul in
let tmp3 = sub tmp 10ul 5ul in
let tmp4 = sub tmp 15ul 5ul in
let x1 = getx p in
let y1 = gety p in
let x2 = getx q in
let y2 = gety q in
fdifference tmp1 y1 x1; // tmp1 = y1 - x1
fdifference tmp2 y2 x2; // tmp2 = y2 - x2
fmul tmp3 tmp1 tmp2; // tmp3 = a
fsum tmp1 y1 x1; // tmp1 = y1 + x1
fsum tmp2 y2 x2; // tmp2 = y2 + x2
fmul tmp4 tmp1 tmp2 // tmp4 = b
inline_for_extraction noextract
val point_add_step_2: p:point -> q:point -> tmp:lbuffer uint64 30ul -> Stack unit
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q /\
F51.mul_inv_t h (gsub tmp 10ul 5ul) /\
F51.mul_inv_t h (gsub tmp 15ul 5ul))
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
(let z1 = F51.fevalh h0 (gsub p 10ul 5ul) in
let t1 = F51.fevalh h0 (gsub p 15ul 5ul) in
let z2 = F51.fevalh h0 (gsub q 10ul 5ul) in
let t2 = F51.fevalh h0 (gsub q 15ul 5ul) in
let a = F51.fevalh h0 (gsub tmp 10ul 5ul) in
let b = F51.fevalh h0 (gsub tmp 15ul 5ul) in
let c = (2 `SC.fmul` Spec.Ed25519.d `SC.fmul` t1) `SC.fmul` t2 in
let d = (2 `SC.fmul` z1) `SC.fmul` z2 in
let e = b `SC.fsub` a in
let f = d `SC.fsub` c in
let g = d `SC.fadd` c in
let h = b `SC.fadd` a in
F51.felem_fits h1 (gsub tmp 20ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 25ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 0ul 5ul) (9, 10, 9, 9, 9) /\
F51.felem_fits h1 (gsub tmp 5ul 5ul) (9, 10, 9, 9, 9) /\
F51.fevalh h1 (gsub tmp 20ul 5ul) == e /\
F51.fevalh h1 (gsub tmp 25ul 5ul) == f /\
F51.fevalh h1 (gsub tmp 0ul 5ul) == g /\
F51.fevalh h1 (gsub tmp 5ul 5ul) == h)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointAdd.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p: Hacl.Bignum25519.point ->
q: Hacl.Bignum25519.point ->
tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 30ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum25519.fsum",
"Prims.unit",
"Hacl.Bignum25519.fdifference",
"Hacl.Bignum25519.fmul",
"Hacl.Bignum25519.times_2",
"Hacl.Bignum25519.times_2d",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.gett",
"Hacl.Bignum25519.getz",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub"
] | [] | false | true | false | false | false | let point_add_step_2 p q tmp =
| let tmp1 = sub tmp 0ul 5ul in
let tmp2 = sub tmp 5ul 5ul in
let tmp3 = sub tmp 10ul 5ul in
let tmp4 = sub tmp 15ul 5ul in
let tmp5 = sub tmp 20ul 5ul in
let tmp6 = sub tmp 25ul 5ul in
let z1 = getz p in
let t1 = gett p in
let z2 = getz q in
let t2 = gett q in
times_2d tmp1 t1;
fmul tmp1 tmp1 t2;
times_2 tmp2 z1;
fmul tmp2 tmp2 z2;
fdifference tmp5 tmp4 tmp3;
fdifference tmp6 tmp2 tmp1;
fsum tmp1 tmp2 tmp1;
fsum tmp2 tmp4 tmp3 | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_empty | val parse32_empty:parser32 parse_empty | val parse32_empty:parser32 parse_empty | let parse32_empty : parser32 parse_empty = parse32_ret () | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 57,
"end_line": 18,
"start_col": 0,
"start_line": 18
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } ))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowParse.SLow.Base.parser32 LowParse.Spec.Combinators.parse_empty | Prims.Tot | [
"total"
] | [] | [
"LowParse.SLow.Combinators.parse32_ret",
"Prims.unit"
] | [] | false | false | false | true | false | let parse32_empty:parser32 parse_empty =
| parse32_ret () | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_ret | val parse32_ret (#t: Type) (x: t) : Tot (parser32 (parse_ret x)) | val parse32_ret (#t: Type) (x: t) : Tot (parser32 (parse_ret x)) | let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } ))) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 109,
"end_line": 15,
"start_col": 0,
"start_line": 11
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: t -> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_ret x) | Prims.Tot | [
"total"
] | [] | [
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Mktuple2",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Native.option",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"LowParse.SLow.Base.parser32"
] | [] | false | false | false | false | false | let parse32_ret (#t: Type) (x: t) : Tot (parser32 (parse_ret x)) =
| (fun input ->
((Some (x, 0ul)) <: (res: option (t * U32.t) {parser32_correct (parse_ret x) input res}))) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_synth' | val serialize32_synth' : p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: LowParse.Spec.Base.serializer p1 ->
s1': LowParse.SLow.Base.serializer32 s1 ->
g1: (_: t2 -> t1) ->
u200:
u203:
Prims.unit
{ LowParse.Spec.Combinators.synth_inverse f2 g1 /\
LowParse.Spec.Combinators.synth_injective f2 }
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 u200) | let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 53,
"end_line": 288,
"start_col": 0,
"start_line": 275
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: LowParse.Spec.Base.serializer p1 ->
s1': LowParse.SLow.Base.serializer32 s1 ->
g1: (_: t2 -> t1) ->
u200:
u203:
Prims.unit
{ LowParse.Spec.Combinators.synth_inverse f2 g1 /\
LowParse.Spec.Combinators.synth_injective f2 }
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 u200) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.SLow.Combinators.serialize32_synth",
"Prims.eq2",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth"
] | [] | false | false | false | false | false | let serialize32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': serializer32 s1)
(g1: (t2 -> Tot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
=
| serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u | false |
|
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_kind_precond | val serialize32_kind_precond (k1 k2: parser_kind) : GTot bool | val serialize32_kind_precond (k1 k2: parser_kind) : GTot bool | let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296 | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 72,
"end_line": 113,
"start_col": 0,
"start_line": 108
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | k1: LowParse.Spec.Base.parser_kind -> k2: LowParse.Spec.Base.parser_kind -> Prims.GTot Prims.bool | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.bool"
] | [] | false | false | false | false | false | let serialize32_kind_precond (k1 k2: parser_kind) : GTot bool =
| Some? k1.parser_kind_high && Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296 | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_false | val serialize32_false:serializer32 #_ #_ #parse_false serialize_false | val serialize32_false:serializer32 #_ #_ #parse_false serialize_false | let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 102,
"end_line": 52,
"start_col": 0,
"start_line": 52
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowParse.SLow.Base.serializer32 LowParse.Spec.Combinators.serialize_false | Prims.Tot | [
"total"
] | [] | [
"Prims.squash",
"Prims.l_False",
"FStar.Bytes.empty_bytes",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.parse_false_kind",
"LowParse.Spec.Combinators.parse_false",
"LowParse.Spec.Combinators.serialize_false"
] | [] | false | false | false | true | false | let serialize32_false:serializer32 #_ #_ #parse_false serialize_false =
| fun input -> B32.empty_bytes | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_compose_context | val parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(p32: (k: kt1 -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k))) | val parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(p32: (k: kt1 -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k))) | let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 30,
"end_line": 470,
"start_col": 0,
"start_line": 461
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: (_: kt2 -> kt1) ->
t: (_: kt1 -> Type) ->
p: (k: kt1 -> LowParse.Spec.Base.parser pk (t k)) ->
p32: (k: kt1 -> LowParse.SLow.Base.parser32 (p k)) ->
k: kt2
-> LowParse.SLow.Base.parser32 (p (f k)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"LowParse.SLow.Base.parser32_correct"
] | [] | false | false | false | false | false | let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(p32: (k: kt1 -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k))) =
| fun input -> p32 (f k) input | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_false | val parse32_false:parser32 parse_false | val parse32_false:parser32 parse_false | let parse32_false : parser32 parse_false = fun _ -> None | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 56,
"end_line": 49,
"start_col": 0,
"start_line": 49
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowParse.SLow.Base.parser32 LowParse.Spec.Combinators.parse_false | Prims.Tot | [
"total"
] | [] | [
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_False",
"FStar.UInt32.t",
"FStar.Pervasives.Native.option",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.parse_false_kind",
"LowParse.Spec.Combinators.parse_false"
] | [] | false | false | false | true | false | let parse32_false:parser32 parse_false =
| fun _ -> None | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_compose_context | val serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(s: (k: kt1 -> Tot (serializer (p k))))
(s32: (k: kt1 -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k))) | val serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(s: (k: kt1 -> Tot (serializer (p k))))
(s32: (k: kt1 -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k))) | let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 30,
"end_line": 483,
"start_col": 0,
"start_line": 473
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: (_: kt2 -> kt1) ->
t: (_: kt1 -> Type) ->
p: (k: kt1 -> LowParse.Spec.Base.parser pk (t k)) ->
s: (k: kt1 -> LowParse.Spec.Base.serializer (p k)) ->
s32: (k: kt1 -> LowParse.SLow.Base.serializer32 (s k)) ->
k: kt2
-> LowParse.SLow.Base.serializer32 (s (f k)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct"
] | [] | false | false | false | false | false | let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(s: (k: kt1 -> Tot (serializer (p k))))
(s32: (k: kt1 -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k))) =
| fun input -> s32 (f k) input | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_empty | val size32_empty:size32 #_ #_ #parse_empty serialize_empty | val size32_empty:size32 #_ #_ #parse_empty serialize_empty | let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ()) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 46,
"start_col": 0,
"start_line": 45
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowParse.SLow.Base.size32 LowParse.Spec.Combinators.serialize_empty | Prims.Tot | [
"total"
] | [] | [
"LowParse.SLow.Combinators.size32_ret",
"Prims.unit"
] | [] | false | false | false | true | false | let size32_empty:size32 #_ #_ #parse_empty serialize_empty =
| size32_ret () (fun _ -> ()) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_compose_context | val size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(s: (k: kt1 -> Tot (serializer (p k))))
(s32: (k: kt1 -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k))) | val size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(s: (k: kt1 -> Tot (serializer (p k))))
(s32: (k: kt1 -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k))) | let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 30,
"end_line": 496,
"start_col": 0,
"start_line": 486
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: (_: kt2 -> kt1) ->
t: (_: kt1 -> Type) ->
p: (k: kt1 -> LowParse.Spec.Base.parser pk (t k)) ->
s: (k: kt1 -> LowParse.Spec.Base.serializer (p k)) ->
s32: (k: kt1 -> LowParse.SLow.Base.size32 (s k)) ->
k: kt2
-> LowParse.SLow.Base.size32 (s (f k)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond"
] | [] | false | false | false | false | false | let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(s: (k: kt1 -> Tot (serializer (p k))))
(s32: (k: kt1 -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k))) =
| fun input -> s32 (f k) input | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_ret | val serialize32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer32 (serialize_ret v v_unique)) | val serialize32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer32 (serialize_ret v v_unique)) | let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 103,
"end_line": 30,
"start_col": 0,
"start_line": 21
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: t -> v_unique: (v': t -> FStar.Pervasives.Lemma (ensures v == v'))
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_ret v v_unique) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"LowParse.Spec.Combinators.serialize_ret",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Bytes.byte",
"FStar.Bytes.reveal",
"FStar.Seq.Base.empty",
"FStar.Bytes.lbytes",
"FStar.Bytes.empty_bytes",
"LowParse.SLow.Base.serializer32"
] | [] | false | false | false | false | false | let serialize32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer32 (serialize_ret v v_unique)) =
| fun input ->
[@@ inline_let ]let b = B32.empty_bytes in
assert ((B32.reveal b) `Seq.equal` Seq.empty);
(b <: (b: bytes32{serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_dtuple2 | val serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind{serialize32_kind_precond k1 k2})
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> serializer32 (s2 x)))
: Tot (serializer32 (serialize_dtuple2 s1 s2)) | val serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind{serialize32_kind_precond k1 k2})
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> serializer32 (s2 x)))
: Tot (serializer32 (serialize_dtuple2 s1 s2)) | let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 81,
"end_line": 196,
"start_col": 0,
"start_line": 170
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1':
LowParse.SLow.Base.serializer32 s1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2': (x: t1 -> LowParse.SLow.Base.serializer32 (s2 x))
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_dtuple2 s1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"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.b2t",
"LowParse.SLow.Combinators.serialize32_kind_precond",
"Prims.dtuple2",
"FStar.Bytes.append",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_dtuple2",
"LowParse.Spec.Combinators.serialize_dtuple2",
"Prims.unit",
"Prims._assert",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.Bytes.length",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Combinators.serialize_dtuple2_eq"
] | [] | false | false | false | false | false | let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind{serialize32_kind_precond k1 k2})
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> serializer32 (s2 x)))
: Tot (serializer32 (serialize_dtuple2 s1 s2)) =
| fun (input: dtuple2 t1 t2) ->
[@@ inline_let ]let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs , sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@@ inline_let ]let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@@ inline_let ]let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2)
<:
(res: bytes32{serializer32_correct (serialize_dtuple2 s1 s2) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_ret | val size32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique)) | val size32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique)) | let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul () | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 72,
"end_line": 42,
"start_col": 0,
"start_line": 37
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: t -> v_unique: (v': t -> FStar.Pervasives.Lemma (ensures v == v'))
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_ret v v_unique) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.SLow.Base.size32_constant",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"LowParse.Spec.Combinators.serialize_ret",
"FStar.UInt32.__uint_to_t",
"LowParse.SLow.Base.size32"
] | [] | false | false | false | false | false | let size32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique)) =
| size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul () | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_empty | val serialize32_empty:serializer32 #_ #_ #parse_empty serialize_empty | val serialize32_empty:serializer32 #_ #_ #parse_empty serialize_empty | let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ()) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowParse.SLow.Base.serializer32 LowParse.Spec.Combinators.serialize_empty | Prims.Tot | [
"total"
] | [] | [
"LowParse.SLow.Combinators.serialize32_ret",
"Prims.unit"
] | [] | false | false | false | true | false | let serialize32_empty:serializer32 #_ #_ #parse_empty serialize_empty =
| serialize32_ret () (fun _ -> ()) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_false | val size32_false:size32 #_ #_ #parse_false serialize_false | val size32_false:size32 #_ #_ #parse_false serialize_false | let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 79,
"end_line": 55,
"start_col": 0,
"start_line": 55
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowParse.SLow.Base.size32 LowParse.Spec.Combinators.serialize_false | Prims.Tot | [
"total"
] | [] | [
"Prims.squash",
"Prims.l_False",
"FStar.UInt32.__uint_to_t",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.Combinators.parse_false_kind",
"LowParse.Spec.Combinators.parse_false",
"LowParse.Spec.Combinators.serialize_false"
] | [] | false | false | false | true | false | let size32_false:size32 #_ #_ #parse_false serialize_false =
| fun input -> 0ul | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_nondep_then | val serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2 {serialize32_kind_precond k1 k2})
: Tot (serializer32 (serialize_nondep_then s1 s2)) | val serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2 {serialize32_kind_precond k1 k2})
: Tot (serializer32 (serialize_nondep_then s1 s2)) | let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 85,
"end_line": 142,
"start_col": 0,
"start_line": 116
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1':
LowParse.SLow.Base.serializer32 s1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2':
LowParse.SLow.Base.serializer32 s2 {LowParse.SLow.Combinators.serialize32_kind_precond k1 k2}
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_nondep_then s1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"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.b2t",
"LowParse.SLow.Combinators.serialize32_kind_precond",
"FStar.Pervasives.Native.tuple2",
"FStar.Bytes.append",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Spec.Combinators.serialize_nondep_then",
"Prims.unit",
"Prims._assert",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.Bytes.length",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Combinators.serialize_nondep_then_eq"
] | [] | false | false | false | false | false | let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2 {serialize32_kind_precond k1 k2})
: Tot (serializer32 (serialize_nondep_then s1 s2)) =
| fun (input: t1 * t2) ->
[@@ inline_let ]let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| fs, sn ->
let output1 = s1' fs in
let output2 = s2' sn in
[@@ inline_let ]let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@@ inline_let ]let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2)
<:
(res: bytes32{serializer32_correct (serialize_nondep_then s1 s2) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_synth' | val parse32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': parser32 p1)
(u: unit{synth_injective f2})
: Tot (parser32 (parse_synth p1 f2)) | val parse32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': parser32 p1)
(u: unit{synth_injective f2})
: Tot (parser32 (parse_synth p1 f2)) | let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 43,
"end_line": 251,
"start_col": 0,
"start_line": 240
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> t2) ->
p1': LowParse.SLow.Base.parser32 p1 ->
u160: u162: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.SLow.Combinators.parse32_synth",
"Prims.eq2",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let parse32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': parser32 p1)
(u: unit{synth_injective f2})
: Tot (parser32 (parse_synth p1 f2)) =
| parse32_synth p1 f2 (fun x -> f2 x) p1' u | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_nondep_then | val parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': parser32 p2)
: Tot (parser32 (nondep_then p1 p2)) | val parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': parser32 p2)
: Tot (parser32 (nondep_then p1 p2)) | let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 95,
"end_line": 106,
"start_col": 0,
"start_line": 84
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p1': LowParse.SLow.Base.parser32 p1 -> p2': LowParse.SLow.Base.parser32 p2
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.nondep_then p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.UInt32.add",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"FStar.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Bytes.reveal",
"FStar.Seq.Base.slice",
"FStar.UInt32.v",
"FStar.Bytes.len",
"FStar.Bytes.slice",
"Prims.unit",
"LowParse.Spec.Combinators.nondep_then_eq"
] | [] | false | false | false | false | false | let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': parser32 p2)
: Tot (parser32 (nondep_then p1 p2)) =
| fun (input: bytes32) ->
(([@@ inline_let ]let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
(match p2' input' with
| Some (v', l') -> Some ((v, v'), U32.add l l')
| _ -> None)
| _ -> None)
<:
(res: option ((t1 * t2) * U32.t) {parser32_correct (p1 `nondep_then` p2) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_and_then | val parse32_and_then
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
(u: unit{and_then_cases_injective p'})
(p32': (x: t -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p')) | val parse32_and_then
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
(u: unit{and_then_cases_injective p'})
(p32': (x: t -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p')) | let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 84,
"end_line": 81,
"start_col": 0,
"start_line": 58
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p32: LowParse.SLow.Base.parser32 p ->
p': (_: t -> LowParse.Spec.Base.parser k' t') ->
u43: u46: Prims.unit{LowParse.Spec.Combinators.and_then_cases_injective p'} ->
p32': (x: t -> LowParse.SLow.Base.parser32 (p' x))
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.and_then p p') | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"Prims.unit",
"LowParse.Spec.Combinators.and_then_cases_injective",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.UInt32.add",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.and_then",
"FStar.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Bytes.reveal",
"FStar.Seq.Base.slice",
"FStar.UInt32.v",
"FStar.Bytes.len",
"FStar.Bytes.slice",
"LowParse.Spec.Combinators.and_then_eq"
] | [] | false | false | false | false | false | let parse32_and_then
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
(u: unit{and_then_cases_injective p'})
(p32': (x: t -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p')) =
| fun (input: bytes32) ->
(([@@ inline_let ]let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
(match p32' v input' with
| Some (v', l') -> Some (v', U32.add l l')
| _ -> None)
| _ -> None)
<:
(res: option (t' * U32.t) {parser32_correct (p `and_then` p') input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_synth | val parse32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': parser32 p1)
(u: unit{synth_injective f2})
: Tot (parser32 (parse_synth p1 f2)) | val parse32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': parser32 p1)
(u: unit{synth_injective f2})
: Tot (parser32 (parse_synth p1 f2)) | let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 87,
"end_line": 237,
"start_col": 0,
"start_line": 219
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
f2': (x: t1 -> y: t2{y == f2 x}) ->
p1': LowParse.SLow.Base.parser32 p1 ->
u147: u151: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.eq2",
"LowParse.SLow.Base.parser32",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.parse_synth_eq",
"FStar.Bytes.reveal"
] | [] | false | false | false | false | false | let parse32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': parser32 p1)
(u: unit{synth_injective f2})
: Tot (parser32 (parse_synth p1 f2)) =
| fun (input: bytes32) ->
(([@@ inline_let ]let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None)
<:
(res: option (t2 * U32.t) {parser32_correct (parse_synth p1 f2) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_filter | val serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f)) | val serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f)) | let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 50,
"end_line": 323,
"start_col": 0,
"start_line": 315
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s32: LowParse.SLow.Base.serializer32 s -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_filter s f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"Prims.bool",
"Prims.eq2",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Combinators.serialize_filter"
] | [] | false | false | false | false | false | let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f)) =
| fun (input: t{f input == true}) -> s32 input | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_synth | val serialize32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': serializer32 s1)
(g1: (t2 -> GTot t1))
(g1': (x: t2 -> Tot (y: t1{y == g1 x})))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u)) | val serialize32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': serializer32 s1)
(g1: (t2 -> GTot t1))
(g1': (x: t2 -> Tot (y: t1{y == g1 x})))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u)) | let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 97,
"end_line": 272,
"start_col": 0,
"start_line": 254
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: LowParse.Spec.Base.serializer p1 ->
s1': LowParse.SLow.Base.serializer32 s1 ->
g1: (_: t2 -> Prims.GTot t1) ->
g1': (x: t2 -> y: t1{y == g1 x}) ->
u183:
u188:
Prims.unit
{ LowParse.Spec.Combinators.synth_inverse f2 g1 /\
LowParse.Spec.Combinators.synth_injective f2 }
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 u183) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"Prims.eq2",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.serialize_synth_eq"
] | [] | false | false | false | false | false | let serialize32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': serializer32 s1)
(g1: (t2 -> GTot t1))
(g1': (x: t2 -> Tot (y: t1{y == g1 x})))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u)) =
| fun (input: t2) ->
[@@ inline_let ]let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32{serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_dtuple2 | val parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(p2': (x: t1 -> Tot (parser32 (p2 x))))
: Tot (parser32 (parse_dtuple2 p1 p2)) | val parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(p2': (x: t1 -> Tot (parser32 (p2 x))))
: Tot (parser32 (parse_dtuple2 p1 p2)) | let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 99,
"end_line": 167,
"start_col": 0,
"start_line": 145
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p1': LowParse.SLow.Base.parser32 p1 -> p2': (x: t1 -> LowParse.SLow.Base.parser32 (p2 x))
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Prims.dtuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Mkdtuple2",
"FStar.UInt32.add",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_dtuple2",
"FStar.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Bytes.reveal",
"FStar.Seq.Base.slice",
"FStar.UInt32.v",
"FStar.Bytes.len",
"FStar.Bytes.slice",
"Prims.unit",
"LowParse.Spec.Combinators.parse_dtuple2_eq"
] | [] | false | false | false | false | false | let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(p2': (x: t1 -> Tot (parser32 (p2 x))))
: Tot (parser32 (parse_dtuple2 p1 p2)) =
| fun (input: bytes32) ->
(([@@ inline_let ]let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
(match p2' v input' with
| Some (v', l') -> Some ((| v, v' |), U32.add l l')
| _ -> None)
| _ -> None)
<:
(res: option (dtuple2 t1 t2 * U32.t) {parser32_correct (parse_dtuple2 p1 p2) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_filter | val size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f)) | val size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f)) | let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 419,
"start_col": 0,
"start_line": 411
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s32: LowParse.SLow.Base.size32 s -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_filter s f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"Prims.bool",
"LowParse.Spec.Combinators.parse_filter_refine",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Combinators.serialize_filter"
] | [] | false | false | false | false | false | let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f)) =
| fun x -> s32 x | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_synth | val size32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': size32 s1)
(g1: (t2 -> GTot t1))
(g1': (x: t2 -> Tot (y: t1{y == g1 x})))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u)) | val size32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': size32 s1)
(g1: (t2 -> GTot t1))
(g1': (x: t2 -> Tot (y: t1{y == g1 x})))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u)) | let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 86,
"end_line": 441,
"start_col": 0,
"start_line": 422
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: LowParse.Spec.Base.serializer p1 ->
s1': LowParse.SLow.Base.size32 s1 ->
g1: (_: t2 -> Prims.GTot t1) ->
g1': (x: t2 -> y: t1{y == g1 x}) ->
u321:
u326:
Prims.unit
{ LowParse.Spec.Combinators.synth_inverse f2 g1 /\
LowParse.Spec.Combinators.synth_injective f2 }
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 u321) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"Prims.eq2",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.serialize_synth_eq"
] | [] | false | false | false | false | false | let size32_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': size32 s1)
(g1: (t2 -> GTot t1))
(g1': (x: t2 -> Tot (y: t1{y == g1 x})))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u)) =
| fun (input: t2) ->
[@@ inline_let ]let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@@ inline_let ]let x = g1' input in
[@@ inline_let ]let y = s1' x in
(y <: (res: U32.t{size32_postcond (serialize_synth p1 f2 s1 g1 u) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.make_total_constant_size_parser32 | val make_total_constant_size_parser32
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (t)))
(u: unit{make_total_constant_size_parser_precond sz t f})
(f': (s: B32.lbytes sz -> Tot (y: t{y == f (B32.reveal s)})))
: Tot (parser32 (make_total_constant_size_parser sz t f)) | val make_total_constant_size_parser32
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (t)))
(u: unit{make_total_constant_size_parser_precond sz t f})
(f': (s: B32.lbytes sz -> Tot (y: t{y == f (B32.reveal s)})))
: Tot (parser32 (make_total_constant_size_parser sz t f)) | let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 106,
"end_line": 364,
"start_col": 0,
"start_line": 348
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
sz: Prims.nat ->
sz': FStar.UInt32.t{FStar.UInt32.v sz' == sz} ->
f: (s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz} -> Prims.GTot t) ->
u244: u249: Prims.unit{LowParse.Spec.Combinators.make_total_constant_size_parser_precond sz t f} ->
f': (s: FStar.Bytes.lbytes sz -> y: t{y == f (FStar.Bytes.reveal s)})
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.make_total_constant_size_parser sz t f) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"LowParse.Spec.Combinators.make_total_constant_size_parser_precond",
"FStar.Bytes.lbytes",
"FStar.Bytes.reveal",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.lt",
"FStar.Bytes.len",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Prims.bool",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Bytes.bytes",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Seq.Base.slice",
"FStar.UInt32.uint_to_t",
"FStar.Bytes.slice",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Native.option",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Base.total_constant_size_parser_kind",
"LowParse.Spec.Combinators.make_total_constant_size_parser",
"LowParse.SLow.Base.parser32"
] | [] | false | false | false | false | false | let make_total_constant_size_parser32
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (t)))
(u: unit{make_total_constant_size_parser_precond sz t f})
(f': (s: B32.lbytes sz -> Tot (y: t{y == f (B32.reveal s)})))
: Tot (parser32 (make_total_constant_size_parser sz t f)) =
| fun (input: bytes32) ->
((if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz'))
<:
(res: option (t * U32.t) {parser32_correct (make_total_constant_size_parser sz t f) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_strengthen | val parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1': parser32 p1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf)) | val parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1': parser32 p1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf)) | let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 109,
"end_line": 216,
"start_col": 0,
"start_line": 199
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1': LowParse.SLow.Base.parser32 p1 ->
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_strengthen p1 p2 prf) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"FStar.Bytes.reveal",
"FStar.UInt32.v",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.parse_strengthen"
] | [] | false | false | false | false | false | let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1': parser32 p1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf)) =
| fun (xbytes: bytes32) ->
((match p1' xbytes with
| Some (x, consumed) ->
[@@ inline_let ]let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@@ inline_let ]let x':x': t1{p2 x'} = x in
Some (x', consumed)
| _ -> None)
<:
(res: option ((x: t1{p2 x}) * U32.t) {parser32_correct (parse_strengthen p1 p2 prf) xbytes res})
) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.make_constant_size_parser32 | val make_constant_size_parser32
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
(u: unit{make_constant_size_parser_precond sz t f})
(f': (s: B32.lbytes sz -> Tot (y: option t {y == f (B32.reveal s)})))
: Tot (parser32 (make_constant_size_parser sz t f)) | val make_constant_size_parser32
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
(u: unit{make_constant_size_parser_precond sz t f})
(f': (s: B32.lbytes sz -> Tot (y: option t {y == f (B32.reveal s)})))
: Tot (parser32 (make_constant_size_parser sz t f)) | let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 100,
"end_line": 345,
"start_col": 0,
"start_line": 326
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
sz: Prims.nat ->
sz': FStar.UInt32.t{FStar.UInt32.v sz' == sz} ->
f:
(s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t)) ->
u232: u237: Prims.unit{LowParse.Spec.Combinators.make_constant_size_parser_precond sz t f} ->
f':
(s: FStar.Bytes.lbytes sz
-> y: FStar.Pervasives.Native.option t {y == f (FStar.Bytes.reveal s)})
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.make_constant_size_parser sz t f) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.option",
"Prims.unit",
"LowParse.Spec.Combinators.make_constant_size_parser_precond",
"FStar.Bytes.lbytes",
"FStar.Bytes.reveal",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.lt",
"FStar.Bytes.len",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Prims.bool",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.constant_size_parser_kind",
"LowParse.Spec.Combinators.make_constant_size_parser",
"FStar.Bytes.bytes",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Seq.Base.slice",
"FStar.UInt32.uint_to_t",
"FStar.Bytes.slice",
"FStar.UInt32.__uint_to_t",
"LowParse.SLow.Base.parser32"
] | [] | false | false | false | false | false | let make_constant_size_parser32
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
(u: unit{make_constant_size_parser_precond sz t f})
(f': (s: B32.lbytes sz -> Tot (y: option t {y == f (B32.reveal s)})))
: Tot (parser32 (make_constant_size_parser sz t f)) =
| fun (input: bytes32) ->
((if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz'))
<:
(res: option (t * U32.t) {parser32_correct (make_constant_size_parser sz t f) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_filter | val parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: (x: t -> Tot (b: bool{b == f x})))
: Tot (parser32 (parse_filter p f)) | val parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: (x: t -> Tot (b: bool{b == f x})))
: Tot (parser32 (parse_filter p f)) | let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 108,
"end_line": 312,
"start_col": 0,
"start_line": 291
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p32: LowParse.SLow.Base.parser32 p ->
f: (_: t -> Prims.GTot Prims.bool) ->
g: (x: t -> b: Prims.bool{b == f x})
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_filter p f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"Prims.bool",
"Prims.eq2",
"LowParse.SLow.Base.bytes32",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter",
"Prims.unit",
"LowParse.Spec.Combinators.parse_filter_eq",
"FStar.Bytes.reveal"
] | [] | false | false | false | false | false | let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: (x: t -> Tot (b: bool{b == f x})))
: Tot (parser32 (parse_filter p f)) =
| fun (input: bytes32) ->
(([@@ inline_let ]let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@@ inline_let ]let v':v': t{f v' == true} = v in
Some (v', consumed)
else None
| _ -> None)
<:
(res: option ((v': t{f v' == true}) * U32.t) {parser32_correct (parse_filter p f) input res})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_nondep_then | val size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': size32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2)) | val size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': size32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2)) | let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 79,
"end_line": 386,
"start_col": 0,
"start_line": 367
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1':
LowParse.SLow.Base.size32 s1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2': LowParse.SLow.Base.size32 s2
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_nondep_then s1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"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",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Spec.Combinators.serialize_nondep_then",
"LowParse.SLow.Base.add_overflow",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_nondep_then_eq"
] | [] | false | false | false | false | false | let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': size32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2)) =
| fun x ->
[@@ inline_let ]let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| x1, x2 ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z: U32.t{size32_postcond (serialize_nondep_then s1 s2) x z})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_synth' | val size32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': size32 s1)
(g1: (t2 -> Tot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u)) | val size32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': size32 s1)
(g1: (t2 -> Tot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u)) | let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 48,
"end_line": 458,
"start_col": 0,
"start_line": 444
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: LowParse.Spec.Base.serializer p1 ->
s1': LowParse.SLow.Base.size32 s1 ->
g1: (_: t2 -> t1) ->
u338:
u341:
Prims.unit
{ LowParse.Spec.Combinators.synth_inverse f2 g1 /\
LowParse.Spec.Combinators.synth_injective f2 }
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 u338) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.SLow.Combinators.size32_synth",
"Prims.eq2",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth"
] | [] | false | false | false | false | false | let size32_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(s1': size32 s1)
(g1: (t2 -> Tot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u)) =
| size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_dtuple2 | val size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': size32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> Tot (size32 (s2 x))))
: Tot (size32 (serialize_dtuple2 s1 s2)) | val size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': size32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> Tot (size32 (s2 x))))
: Tot (size32 (serialize_dtuple2 s1 s2)) | let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } )) | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 75,
"end_line": 408,
"start_col": 0,
"start_line": 389
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1':
LowParse.SLow.Base.size32 s1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2': (x: t1 -> LowParse.SLow.Base.size32 (s2 x))
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_dtuple2 s1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"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.dtuple2",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_dtuple2",
"LowParse.Spec.Combinators.serialize_dtuple2",
"LowParse.SLow.Base.add_overflow",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_dtuple2_eq"
] | [] | false | false | false | false | false | let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': size32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> Tot (size32 (s2 x))))
: Tot (size32 (serialize_dtuple2 s1 s2)) =
| fun x ->
[@@ inline_let ]let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1 , x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z: U32.t{size32_postcond (serialize_dtuple2 s1 s2) x z})) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_weaken | val parse32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2': parser32 p2 {k1 `is_weaker_than` k2})
: Tot (parser32 (weaken k1 p2)) | val parse32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2': parser32 p2 {k1 `is_weaker_than` k2})
: Tot (parser32 (weaken k1 p2)) | let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 506,
"start_col": 0,
"start_line": 499
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
k1: LowParse.Spec.Base.parser_kind ->
p2': LowParse.SLow.Base.parser32 p2 {LowParse.Spec.Base.is_weaker_than k1 k2}
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Base.weaken k1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.Spec.Base.is_weaker_than",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Base.weaken"
] | [] | false | false | false | false | false | let parse32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2': parser32 p2 {k1 `is_weaker_than` k2})
: Tot (parser32 (weaken k1 p2)) =
| fun x -> p2' x | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.lift_parser32 | val lift_parser32
(#k: parser_kind)
(#t: Type)
(f: (unit -> GTot (parser k t)))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f)) | val lift_parser32
(#k: parser_kind)
(#t: Type)
(f: (unit -> GTot (parser k t)))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f)) | let lift_parser32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f))
= fun x -> f32 x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 537,
"start_col": 0,
"start_line": 531
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x
inline_for_extraction
let serialize32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : serializer32 s2 { k1 `is_weaker_than` k2 })
: Tot (serializer32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let size32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : size32 s2 { k1 `is_weaker_than` k2 })
: Tot (size32 (serialize_weaken k1 s2))
= fun x -> s2' x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: (_: Prims.unit -> Prims.GTot (LowParse.Spec.Base.parser k t)) ->
f32: LowParse.SLow.Base.parser32 (f ())
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.lift_parser f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.lift_parser"
] | [] | false | false | false | false | false | let lift_parser32
(#k: parser_kind)
(#t: Type)
(f: (unit -> GTot (parser k t)))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f)) =
| fun x -> f32 x | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.size32_weaken | val size32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2': size32 s2 {k1 `is_weaker_than` k2})
: Tot (size32 (serialize_weaken k1 s2)) | val size32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2': size32 s2 {k1 `is_weaker_than` k2})
: Tot (size32 (serialize_weaken k1 s2)) | let size32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : size32 s2 { k1 `is_weaker_than` k2 })
: Tot (size32 (serialize_weaken k1 s2))
= fun x -> s2' x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 528,
"start_col": 0,
"start_line": 520
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x
inline_for_extraction
let serialize32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : serializer32 s2 { k1 `is_weaker_than` k2 })
: Tot (serializer32 (serialize_weaken k1 s2))
= fun x -> s2' x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
k1: LowParse.Spec.Base.parser_kind ->
s2': LowParse.SLow.Base.size32 s2 {LowParse.Spec.Base.is_weaker_than k1 k2}
-> LowParse.SLow.Base.size32 (LowParse.Spec.Combinators.serialize_weaken k1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"LowParse.Spec.Base.is_weaker_than",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.Base.weaken",
"LowParse.Spec.Combinators.serialize_weaken"
] | [] | false | false | false | false | false | let size32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2': size32 s2 {k1 `is_weaker_than` k2})
: Tot (size32 (serialize_weaken k1 s2)) =
| fun x -> s2' x | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_weaken | val serialize32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2': serializer32 s2 {k1 `is_weaker_than` k2})
: Tot (serializer32 (serialize_weaken k1 s2)) | val serialize32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2': serializer32 s2 {k1 `is_weaker_than` k2})
: Tot (serializer32 (serialize_weaken k1 s2)) | let serialize32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : serializer32 s2 { k1 `is_weaker_than` k2 })
: Tot (serializer32 (serialize_weaken k1 s2))
= fun x -> s2' x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 517,
"start_col": 0,
"start_line": 509
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
k1: LowParse.Spec.Base.parser_kind ->
s2': LowParse.SLow.Base.serializer32 s2 {LowParse.Spec.Base.is_weaker_than k1 k2}
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_weaken k1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"LowParse.Spec.Base.is_weaker_than",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Base.weaken",
"LowParse.Spec.Combinators.serialize_weaken"
] | [] | false | false | false | false | false | let serialize32_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2': serializer32 s2 {k1 `is_weaker_than` k2})
: Tot (serializer32 (serialize_weaken k1 s2)) =
| fun x -> s2' x | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.lift_serializer32 | val lift_serializer32
(#k: parser_kind)
(#t: Type)
(f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
(s32: serializer32 (s ()))
: Tot (serializer32 (lift_serializer #k #t #f s)) | val lift_serializer32
(#k: parser_kind)
(#t: Type)
(f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
(s32: serializer32 (s ()))
: Tot (serializer32 (lift_serializer #k #t #f s)) | let lift_serializer32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
(s32: serializer32 (s ()))
: Tot (serializer32 (lift_serializer #k #t #f s))
= fun x -> s32 x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 547,
"start_col": 0,
"start_line": 540
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x
inline_for_extraction
let serialize32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : serializer32 s2 { k1 `is_weaker_than` k2 })
: Tot (serializer32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let size32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : size32 s2 { k1 `is_weaker_than` k2 })
: Tot (size32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let lift_parser32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f))
= fun x -> f32 x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: (_: Prims.unit -> Prims.GTot (LowParse.Spec.Base.parser k t)) ->
s: (_: Prims.unit -> Prims.GTot (LowParse.Spec.Base.serializer (f ()))) ->
s32: LowParse.SLow.Base.serializer32 (s ())
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.lift_serializer s) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.lift_parser",
"LowParse.Spec.Combinators.lift_serializer"
] | [] | false | false | false | false | false | let lift_serializer32
(#k: parser_kind)
(#t: Type)
(f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
(s32: serializer32 (s ()))
: Tot (serializer32 (lift_serializer #k #t #f s)) =
| fun x -> s32 x | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.serialize32_tagged_union | val serialize32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(#st: serializer pt)
(st32: serializer32 st)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tag_of_data': (x: data_t -> Tot (y: tag_t{y == tag_of_data x})))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(#s: (t: tag_t -> Tot (serializer (p t))))
(s32: (t: tag_t -> Tot (serializer32 (s t))))
(x:
squash (kt.parser_kind_subkind == Some ParserStrong /\
(match kt.parser_kind_high, k.parser_kind_high with
| Some max1, Some max2 -> max1 + max2 < 4294967296
| _ -> False)))
: Tot (serializer32 (serialize_tagged_union st tag_of_data s)) | val serialize32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(#st: serializer pt)
(st32: serializer32 st)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tag_of_data': (x: data_t -> Tot (y: tag_t{y == tag_of_data x})))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(#s: (t: tag_t -> Tot (serializer (p t))))
(s32: (t: tag_t -> Tot (serializer32 (s t))))
(x:
squash (kt.parser_kind_subkind == Some ParserStrong /\
(match kt.parser_kind_high, k.parser_kind_high with
| Some max1, Some max2 -> max1 + max2 < 4294967296
| _ -> False)))
: Tot (serializer32 (serialize_tagged_union st tag_of_data s)) | let serialize32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(#st: serializer pt)
(st32: serializer32 st)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tag_of_data' : ((x: data_t) -> Tot (y: tag_t { y == tag_of_data x })))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#s: (t: tag_t) -> Tot (serializer (p t)))
(s32: (t: tag_t) -> Tot (serializer32 (s t)))
(x: squash (
kt.parser_kind_subkind == Some ParserStrong /\
begin match kt.parser_kind_high, k.parser_kind_high with
| Some max1, Some max2 -> max1 + max2 < 4294967296
| _ -> False
end
))
: Tot (serializer32 (serialize_tagged_union st tag_of_data s))
=
fun x ->
serialize_tagged_union_eq st tag_of_data s x;
let tg = tag_of_data' x in
st32 tg `B32.append` s32 tg x | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 33,
"end_line": 599,
"start_col": 0,
"start_line": 574
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x
inline_for_extraction
let serialize32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : serializer32 s2 { k1 `is_weaker_than` k2 })
: Tot (serializer32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let size32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : size32 s2 { k1 `is_weaker_than` k2 })
: Tot (size32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let lift_parser32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f))
= fun x -> f32 x
inline_for_extraction
let lift_serializer32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
(s32: serializer32 (s ()))
: Tot (serializer32 (lift_serializer #k #t #f s))
= fun x -> s32 x
inline_for_extraction
let parse32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(pt32: parser32 pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(p32: (t: tag_t) -> Tot (parser32 (p t)))
: Tot (parser32 (parse_tagged_union pt tag_of_data p))
=
fun input ->
parse_tagged_union_eq pt tag_of_data p (B32.reveal input);
match pt32 input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = B32.slice input consumed_tg (B32.len input) in
begin match p32 tg input_tg with
| None -> None
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg `U32.add` consumed_x)
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
st32: LowParse.SLow.Base.serializer32 st ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
tag_of_data': (x: data_t -> y: tag_t{y == tag_of_data x}) ->
s32: (t: tag_t -> LowParse.SLow.Base.serializer32 (s t)) ->
x:
Prims.squash (Mkparser_kind'?.parser_kind_subkind kt ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
(match Mkparser_kind'?.parser_kind_high kt, Mkparser_kind'?.parser_kind_high k with
| FStar.Pervasives.Native.Mktuple2
#_
#_
(FStar.Pervasives.Native.Some #_ max1)
(FStar.Pervasives.Native.Some #_ max2) ->
max1 + max2 < 4294967296
| _ -> Prims.l_False))
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.Combinators.serialize_tagged_union st
tag_of_data
s) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"Prims.eq2",
"LowParse.Spec.Base.refine_with_tag",
"Prims.squash",
"Prims.l_and",
"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",
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Pervasives.Native.tuple2",
"Prims.l_False",
"Prims.logical",
"FStar.Bytes.append",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_tagged_union_eq",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"LowParse.Spec.Combinators.serialize_tagged_union"
] | [] | false | false | false | false | false | let serialize32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(#st: serializer pt)
(st32: serializer32 st)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tag_of_data': (x: data_t -> Tot (y: tag_t{y == tag_of_data x})))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(#s: (t: tag_t -> Tot (serializer (p t))))
(s32: (t: tag_t -> Tot (serializer32 (s t))))
(x:
squash (kt.parser_kind_subkind == Some ParserStrong /\
(match kt.parser_kind_high, k.parser_kind_high with
| Some max1, Some max2 -> max1 + max2 < 4294967296
| _ -> False)))
: Tot (serializer32 (serialize_tagged_union st tag_of_data s)) =
| fun x ->
serialize_tagged_union_eq st tag_of_data s x;
let tg = tag_of_data' x in
(st32 tg) `B32.append` (s32 tg x) | false |
LowParse.SLow.Combinators.fst | LowParse.SLow.Combinators.parse32_tagged_union | val parse32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(pt32: parser32 pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(p32: (t: tag_t -> Tot (parser32 (p t))))
: Tot (parser32 (parse_tagged_union pt tag_of_data p)) | val parse32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(pt32: parser32 pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(p32: (t: tag_t -> Tot (parser32 (p t))))
: Tot (parser32 (parse_tagged_union pt tag_of_data p)) | let parse32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(pt32: parser32 pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(p32: (t: tag_t) -> Tot (parser32 (p t)))
: Tot (parser32 (parse_tagged_union pt tag_of_data p))
=
fun input ->
parse_tagged_union_eq pt tag_of_data p (B32.reveal input);
match pt32 input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = B32.slice input consumed_tg (B32.len input) in
begin match p32 tg input_tg with
| None -> None
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg `U32.add` consumed_x)
end | {
"file_name": "src/lowparse/LowParse.SLow.Combinators.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 9,
"end_line": 571,
"start_col": 0,
"start_line": 550
} | module LowParse.SLow.Combinators
include LowParse.SLow.Base
include LowParse.Spec.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
#reset-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
inline_for_extraction
let parse32_ret
(#t: Type)
(x: t)
: Tot (parser32 (parse_ret x))
= (fun input -> ((Some (x, 0ul)) <: (res: option (t * U32.t) { parser32_correct (parse_ret x) input res } )))
inline_for_extraction
let parse32_empty : parser32 parse_empty = parse32_ret ()
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun input ->
[@inline_let]
let b = B32.empty_bytes in
assert (B32.reveal b `Seq.equal` Seq.empty);
(b <: (b: bytes32 { serializer32_correct #_ #_ #(parse_ret v) (serialize_ret v v_unique) input b } ))
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let size32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (size32 #_ #_ #(parse_ret v) (serialize_ret v v_unique))
= size32_constant #_ #_ #(parse_ret v) (serialize_ret v v_unique) 0ul ()
inline_for_extraction
let size32_empty : size32 #_ #_ #parse_empty serialize_empty
= size32_ret () (fun _ -> ())
inline_for_extraction
let parse32_false : parser32 parse_false = fun _ -> None
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false = fun input -> B32.empty_bytes
inline_for_extraction
let size32_false : size32 #_ #_ #parse_false serialize_false = fun input -> 0ul
inline_for_extraction
let parse32_and_then
(#k: parser_kind)
(#t:Type)
(#p:parser k t)
(p32: parser32 p)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(u: unit { and_then_cases_injective p' } )
(p32' : ((x: t) -> Tot (parser32 (p' x))))
: Tot (parser32 (p `and_then` p'))
= fun (input: bytes32) ->
((
[@inline_let] let _ = and_then_eq p p' (B32.reveal input) in
match p32 input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p32' v input' with
| Some (v', l') ->
Some (v', U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (t' * U32.t) { parser32_correct (p `and_then` p') input res } ))
inline_for_extraction
let parse32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : parser32 p2)
: Tot (parser32 (nondep_then p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = nondep_then_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' input' with
| Some (v', l') ->
Some ((v, v'), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option ((t1 * t2) * U32.t) { parser32_correct (p1 `nondep_then` p2) input res } ))
let serialize32_kind_precond
(k1 k2: parser_kind)
: GTot bool
= Some? k1.parser_kind_high &&
Some? k2.parser_kind_high &&
Some?.v k1.parser_kind_high + Some?.v k2.parser_kind_high < 4294967296
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2 {
serialize32_kind_precond k1 k2
})
: Tot (serializer32 (serialize_nondep_then s1 s2))
= fun (input: t1 * t2) ->
[@inline_let]
let _ = serialize_nondep_then_eq s1 s2 input in
match input with
| (fs, sn) ->
let output1 = s1' fs in
let output2 = s2' sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize s2 sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_nondep_then s1 s2) input res } ))
inline_for_extraction
let parse32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : parser32 p1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(p2' : (x: t1) -> Tot (parser32 (p2 x)))
: Tot (parser32 (parse_dtuple2 p1 p2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_dtuple2_eq p1 p2 (B32.reveal input) in
match p1' input with
| Some (v, l) ->
let input' = B32.slice input l (B32.len input) in
begin match p2' v input' with
| Some (v', l') ->
Some ((| v, v' |), U32.add l l')
| _ -> None
end
| _ -> None
) <: (res: option (dtuple2 t1 t2 * U32.t) { parser32_correct (parse_dtuple2 p1 p2) input res } ))
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind {
serialize32_kind_precond k1 k2
})
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (input: dtuple2 t1 t2) ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 input in
match input with
| (| fs, sn |) ->
let output1 = s1' fs in
let output2 = s2' fs sn in
[@inline_let]
let _ = assert (B32.length output1 == Seq.length (serialize s1 fs)) in
[@inline_let]
let _ = assert (B32.length output2 == Seq.length (serialize (s2 fs) sn)) in
((B32.append output1 output2) <:
(res: bytes32 { serializer32_correct (serialize_dtuple2 s1 s2) input res } ))
inline_for_extraction
let parse32_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p1' : parser32 p1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser32 (parse_strengthen p1 p2 prf))
= fun (xbytes: bytes32) -> ((
match p1' xbytes with
| Some (x, consumed) ->
[@inline_let]
let _ = prf (B32.reveal xbytes) (U32.v consumed) x in
[@inline_let]
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
) <: (res: option ((x: t1 { p2 x}) * U32.t) { parser32_correct (parse_strengthen p1 p2 prf) xbytes res } ))
inline_for_extraction
let parse32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_synth_eq p1 f2 (B32.reveal input) in
match p1' input with
| Some (v1, consumed) -> Some (f2' v1, consumed)
| _ -> None
) <: (res: option (t2 * U32.t) { parser32_correct (parse_synth p1 f2) input res } ))
inline_for_extraction
let parse32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : parser32 p1)
(u: unit {
synth_injective f2
})
: Tot (parser32 (parse_synth p1 f2))
= parse32_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
let x = g1' input in
(s1' x <: (res: bytes32 { serializer32_correct (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let serialize32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : serializer32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
= serialize32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(f: (t -> GTot bool))
(g: ((x: t) -> Tot (b: bool { b == f x } )))
: Tot (parser32 (parse_filter p f))
= fun (input: bytes32) ->
((
[@inline_let] let _ = parse_filter_eq p f (B32.reveal input) in
match p32 input with
| Some (v, consumed) ->
if g v
then
[@inline_let]
let (v' : t { f v' == true } ) = v in
Some (v', consumed)
else
None
| _ -> None
) <: (res: option ((v': t { f v' == true } ) * U32.t) { parser32_correct (parse_filter p f) input res } ))
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun (input: t { f input == true } ) -> s32 input
inline_for_extraction
let make_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(u: unit {
make_constant_size_parser_precond sz t f
} )
(f' : ((s: B32.lbytes sz) -> Tot (y: option t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else begin
let s' = B32.slice input 0ul sz' in
match f' s' with
| None -> None
| Some v -> Some (v, sz')
end
) <: (res: option (t * U32.t) { parser32_correct (make_constant_size_parser sz t f) input res } ))
inline_for_extraction
let make_total_constant_size_parser32
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((s: B32.lbytes sz) -> Tot (y: t { y == f (B32.reveal s) } )))
: Tot (parser32 (make_total_constant_size_parser sz t f))
= fun (input: bytes32) -> ((
if U32.lt (B32.len input) sz'
then None
else
let s' = B32.slice input 0ul sz' in
Some (f' s', sz')
) <: (res: option (t * U32.t) { parser32_correct (make_total_constant_size_parser sz t f) input res } ))
inline_for_extraction
let size32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : size32 s2)
: Tot (size32 (serialize_nondep_then s1 s2))
= fun x ->
[@inline_let] let _ = serialize_nondep_then_eq s1 s2 x in
match x with
| (x1, x2) ->
let v1 = s1' x1 in
let v2 = s2' x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_nondep_then s1 s2) x z } ))
inline_for_extraction
let size32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : size32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> Tot (size32 (s2 x)))
: Tot (size32 (serialize_dtuple2 s1 s2))
= fun x ->
[@inline_let] let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
let v1 = s1' x1 in
let v2 = s2' x1 x2 in
let res = add_overflow v1 v2 in
(res <: (z : U32.t { size32_postcond (serialize_dtuple2 s1 s2) x z } ))
inline_for_extraction
let size32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(f: (t -> GTot bool))
: Tot (size32 #_ #_ #(parse_filter p f) (serialize_filter s f))
= fun x -> s32 x
inline_for_extraction
let size32_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> GTot t1)
(g1': (x: t2) -> Tot (y: t1 { y == g1 x } ) )
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= fun (input: t2) ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 u input in
[@inline_let] let x = g1' input in
[@inline_let] let y = s1' x in
(y <: (res: U32.t { size32_postcond (serialize_synth p1 f2 s1 g1 u) input res } ))
inline_for_extraction
let size32_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(s1' : size32 s1)
(g1: t2 -> Tot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (size32 (serialize_synth p1 f2 s1 g1 u))
= size32_synth p1 f2 s1 s1' g1 (fun x -> g1 x) u
inline_for_extraction
let parse32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(p32: ((k: kt1) -> Tot (parser32 (p k))))
(k: kt2)
: Tot (parser32 (p (f k)))
= fun input -> p32 (f k) input
inline_for_extraction
let serialize32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (serializer32 (s k))))
(k: kt2)
: Tot (serializer32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let size32_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(s: ((k: kt1) -> Tot (serializer (p k))))
(s32: ((k: kt1) -> Tot (size32 (s k))))
(k: kt2)
: Tot (size32 (s (f k)))
= fun input -> s32 (f k) input
inline_for_extraction
let parse32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(p2' : parser32 p2 { k1 `is_weaker_than` k2 })
: Tot (parser32 (weaken k1 p2))
= fun x -> p2' x
inline_for_extraction
let serialize32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : serializer32 s2 { k1 `is_weaker_than` k2 })
: Tot (serializer32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let size32_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(#s2: serializer p2)
(s2' : size32 s2 { k1 `is_weaker_than` k2 })
: Tot (size32 (serialize_weaken k1 s2))
= fun x -> s2' x
inline_for_extraction
let lift_parser32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(f32: parser32 (f ()))
: Tot (parser32 (lift_parser f))
= fun x -> f32 x
inline_for_extraction
let lift_serializer32
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
(s32: serializer32 (s ()))
: Tot (serializer32 (lift_serializer #k #t #f s))
= fun x -> s32 x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.SLow.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Bytes",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.SLow",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pt32: LowParse.SLow.Base.parser32 pt ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p32: (t: tag_t -> LowParse.SLow.Base.parser32 (p t))
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Combinators.parse_tagged_union pt tag_of_data p) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.UInt32.add",
"FStar.Pervasives.Native.option",
"LowParse.SLow.Base.parser32_correct",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"FStar.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Bytes.reveal",
"FStar.Seq.Base.slice",
"FStar.UInt32.v",
"FStar.Bytes.len",
"FStar.Bytes.slice",
"Prims.unit",
"LowParse.Spec.Combinators.parse_tagged_union_eq"
] | [] | false | false | false | false | false | let parse32_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(pt32: parser32 pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(p32: (t: tag_t -> Tot (parser32 (p t))))
: Tot (parser32 (parse_tagged_union pt tag_of_data p)) =
| fun input ->
parse_tagged_union_eq pt tag_of_data p (B32.reveal input);
match pt32 input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = B32.slice input consumed_tg (B32.len input) in
match p32 tg input_tg with
| None -> None
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg `U32.add` consumed_x) | false |
Hacl.Impl.Ed25519.Verify.fst | Hacl.Impl.Ed25519.Verify.verify_valid_pk_rs | val verify_valid_pk_rs:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point
-> r':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\
(Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\
(F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | val verify_valid_pk_rs:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point
-> r':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\
(Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\
(F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | let verify_valid_pk_rs public_key msg_len msg signature a' r' =
push_frame ();
let hb = create 32ul (u8 0) in
let rs = sub signature 0ul 32ul in
let sb = sub signature 32ul 32ul in
let b = verify_sb sb in
let res =
if b then false
else begin
Hacl.Impl.SHA512.ModQ.store_sha512_modq_pre_pre2 hb rs public_key msg_len msg;
verify_all_valid_hb sb hb a' r' end in
pop_frame ();
res | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 94,
"start_col": 0,
"start_line": 81
} | module Hacl.Impl.Ed25519.Verify
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module PM = Hacl.Impl.Ed25519.Ladder
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let point_inv_full_t (h:mem) (p:point) =
F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p)
inline_for_extraction noextract
val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool
(requires fun h ->
live h sb /\ live h hb /\ live h a' /\ live h r' /\
point_inv_full_t h a' /\ point_inv_full_t h r')
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z == Spec.Ed25519.(
let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in
point_equal exp_d (F51.point_eval h0 r'))))
let verify_all_valid_hb sb hb a' r' =
push_frame ();
let exp_d = create 20ul (u64 0) in
PM.point_negate_mul_double_g_vartime exp_d sb hb a';
let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_equal_lemma
(F51.point_eval h0 exp_d)
(Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a'))
(F51.point_eval h0 r');
pop_frame ();
b
inline_for_extraction noextract
val verify_sb: sb:lbuffer uint8 32ul -> Stack bool
(requires fun h -> live h sb)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q)))
let verify_sb sb =
push_frame ();
let tmp = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes tmp sb;
let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in
pop_frame ();
b
inline_for_extraction noextract
val verify_valid_pk_rs:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul
-> a':point
-> r':point ->
Stack bool
(requires fun h ->
live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\
(Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\
(F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\
(Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\
(F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))))
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointEqual.fst.checked",
"Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Ladder",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
public_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
msg_len: Lib.IntTypes.size_t ->
msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msg_len ->
signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul ->
a': Hacl.Bignum25519.point ->
r': Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum25519.point",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.Ed25519.Verify.verify_all_valid_hb",
"Hacl.Impl.SHA512.ModQ.store_sha512_modq_pre_pre2",
"Hacl.Impl.Ed25519.Verify.verify_sb",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"Lib.Buffer.create",
"Lib.IntTypes.u8",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let verify_valid_pk_rs public_key msg_len msg signature a' r' =
| push_frame ();
let hb = create 32ul (u8 0) in
let rs = sub signature 0ul 32ul in
let sb = sub signature 32ul 32ul in
let b = verify_sb sb in
let res =
if b
then false
else
(Hacl.Impl.SHA512.ModQ.store_sha512_modq_pre_pre2 hb rs public_key msg_len msg;
verify_all_valid_hb sb hb a' r')
in
pop_frame ();
res | false |
FStar.ST.fst | FStar.ST.gst_post | val gst_post : a: Type -> Type | let gst_post (a:Type) = st_post_h heap a | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 30,
"start_col": 0,
"start_line": 30
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.st_post_h",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let gst_post (a: Type) =
| st_post_h heap a | false |
|
FStar.ST.fst | FStar.ST.gst_pre | val gst_pre : Type | let gst_pre = st_pre_h heap | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.st_pre_h",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let gst_pre =
| st_pre_h heap | false |
|
FStar.ST.fst | FStar.ST.gst_post' | val gst_post' : a: Type -> pre: Type -> Type | let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> pre: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.st_post_h'",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let gst_post' (a pre: Type) =
| st_post_h' heap a pre | false |
|
FStar.ST.fst | FStar.ST.gst_wp | val gst_wp : a: Type -> Type | let gst_wp (a:Type) = st_wp_h heap a | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 31,
"start_col": 0,
"start_line": 31
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.st_wp_h",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let gst_wp (a: Type) =
| st_wp_h heap a | false |
|
FStar.ST.fst | FStar.ST.heap_rel | val heap_rel : h1: FStar.Monotonic.Heap.heap -> h2: FStar.Monotonic.Heap.heap -> Prims.logical | let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r)) | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 38,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h1: FStar.Monotonic.Heap.heap -> h2: FStar.Monotonic.Heap.heap -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Heap.heap",
"Prims.l_Forall",
"FStar.Preorder.preorder",
"FStar.Monotonic.Heap.mref",
"Prims.l_imp",
"FStar.Monotonic.Heap.contains",
"Prims.l_and",
"FStar.Monotonic.Heap.sel",
"Prims.logical"
] | [] | false | false | false | true | true | let heap_rel (h1 h2: heap) =
| forall (a: Type0) (rel: preorder a) (r: mref a rel).
h1 `contains` r ==> (h2 `contains` r /\ rel (sel h1 r) (sel h2 r)) | false |
|
FStar.ST.fst | FStar.ST.lift_div_gst | val lift_div_gst : a: Type -> wp: Prims.pure_wp a -> p: FStar.ST.gst_post a -> h: FStar.Monotonic.Heap.heap
-> Prims.pure_pre | let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h) | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 33,
"start_col": 7,
"start_line": 33
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> wp: Prims.pure_wp a -> p: FStar.ST.gst_post a -> h: FStar.Monotonic.Heap.heap
-> Prims.pure_pre | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_wp",
"FStar.ST.gst_post",
"FStar.Monotonic.Heap.heap",
"Prims.l_True",
"Prims.pure_pre"
] | [] | false | false | false | true | false | let lift_div_gst (a: Type) (wp: pure_wp a) (p: gst_post a) (h: heap) =
| wp (fun a -> p a h) | false |
|
FStar.ST.fst | FStar.ST.stable | val stable : p: FStar.ST.heap_predicate -> Prims.logical | let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2 | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 63,
"end_line": 46,
"start_col": 0,
"start_line": 45
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.heap_predicate -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.heap_predicate",
"Prims.l_Forall",
"FStar.Monotonic.Heap.heap",
"Prims.l_imp",
"Prims.l_and",
"FStar.ST.heap_rel",
"Prims.logical"
] | [] | false | false | false | true | true | let stable (p: heap_predicate) =
| forall (h1: heap) (h2: heap). (p h1 /\ heap_rel h1 h2) ==> p h2 | false |
|
FStar.ST.fst | FStar.ST.st_post' | val st_post' : a: Type -> pre: Type -> Type | let st_post' = gst_post' | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 64,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> pre: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.gst_post'"
] | [] | false | false | false | true | true | let st_post' =
| gst_post' | false |
|
FStar.ST.fst | FStar.ST.st_pre | val st_pre : Type | let st_pre = gst_pre | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 63,
"start_col": 0,
"start_line": 63
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.gst_pre"
] | [] | false | false | false | true | true | let st_pre =
| gst_pre | false |
|
FStar.ST.fst | FStar.ST.st_wp | val st_wp : a: Type -> Type | let st_wp = gst_wp | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 66,
"start_col": 0,
"start_line": 66
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
let st_pre = gst_pre
let st_post' = gst_post' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.gst_wp"
] | [] | false | false | false | true | true | let st_wp =
| gst_wp | false |
|
FStar.ST.fst | FStar.ST.lift_gst_state | val lift_gst_state : a: Type -> wp: FStar.ST.gst_wp a -> FStar.ST.gst_wp a | let lift_gst_state (a:Type) (wp:gst_wp a) = wp | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 70,
"start_col": 7,
"start_line": 70
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
let st_pre = gst_pre
let st_post' = gst_post'
let st_post = gst_post
let st_wp = gst_wp
new_effect STATE = GST | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> wp: FStar.ST.gst_wp a -> FStar.ST.gst_wp a | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.gst_wp"
] | [] | false | false | false | true | false | let lift_gst_state (a: Type) (wp: gst_wp a) =
| wp | false |
|
FStar.ST.fst | FStar.ST.st_post | val st_post : a: Type -> Type | let st_post = gst_post | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 65,
"start_col": 0,
"start_line": 65
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
let st_pre = gst_pre | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.gst_post"
] | [] | false | false | false | true | true | let st_post =
| gst_post | false |
|
FStar.ST.fst | FStar.ST.contains_pred | val contains_pred : r: FStar.Monotonic.Heap.mref a rel -> h: FStar.Monotonic.Heap.heap -> Type0 | let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 87,
"end_line": 79,
"start_col": 0,
"start_line": 79
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.Heap.mref a rel -> h: FStar.Monotonic.Heap.heap -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.Heap.mref",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.Heap.contains"
] | [] | false | false | false | false | true | let contains_pred (#a: Type0) (#rel: preorder a) (r: mref a rel) =
| fun h -> h `contains` r | false |
|
FStar.ST.fst | FStar.ST.op_Bang | val ( ! ) (#a: Type) (#rel: preorder a) (r: mref a rel) : STATE a (fun p h -> p (sel h r) h) | val ( ! ) (#a: Type) (#rel: preorder a) (r: mref a rel) : STATE a (fun p h -> p (sel h r) h) | let op_Bang (#a:Type) (#rel:preorder a) (r:mref a rel)
: STATE a (fun p h -> p (sel h r) h)
= read #a #rel r | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 120,
"start_col": 0,
"start_line": 118
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True)
let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r
type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)}
let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h)
= gst_recall (contains_pred r)
let alloc (#a:Type) (#rel:preorder a) (init:a)
:ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init)
= let h0 = gst_get () in
let r, h1 = alloc rel h0 init false in
gst_put h1;
gst_witness (contains_pred r);
r
let read (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE a (fun p h -> p (sel h r) h)
= let h0 = gst_get () in
gst_recall (contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r;
sel_tot h0 r
let write (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\
modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\
sel h1 r == v)
= let h0 = gst_get () in
gst_recall (contains_pred r);
let h1 = upd_tot h0 r v in
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_upd_equals_upd_tot_for_contained_refs h0 r v;
gst_put h1
let get (u:unit) :ST heap (fun h -> True) (fun h0 h h1 -> h0==h1 /\ h==h1) = gst_get () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.mref a rel -> FStar.ST.STATE a | FStar.ST.STATE | [] | [] | [
"FStar.Preorder.preorder",
"FStar.ST.mref",
"FStar.ST.read",
"FStar.Pervasives.st_post_h",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.Heap.sel"
] | [] | false | true | false | false | false | let ( ! ) (#a: Type) (#rel: preorder a) (r: mref a rel) : STATE a (fun p h -> p (sel h r) h) =
| read #a #rel r | false |
FStar.ST.fst | FStar.ST.lemma_functoriality | val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q)) | val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q)) | let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 59,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)}) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.heap_predicate{FStar.ST.stable p /\ FStar.ST.witnessed p} ->
q:
FStar.ST.heap_predicate
{FStar.ST.stable q /\ (forall (h: FStar.Monotonic.Heap.heap). p h ==> q h)}
-> FStar.Pervasives.Lemma (ensures FStar.ST.witnessed q) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ST.heap_predicate",
"Prims.l_and",
"FStar.ST.stable",
"FStar.ST.witnessed",
"Prims.l_Forall",
"FStar.Monotonic.Heap.heap",
"Prims.l_imp",
"FStar.Monotonic.Witnessed.lemma_witnessed_weakening",
"FStar.ST.heap_rel",
"Prims.unit",
"FStar.Pervasives.reveal_opaque"
] | [] | true | false | true | false | false | let lemma_functoriality p q =
| reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q | false |
FStar.ST.fst | FStar.ST.witnessed | val witnessed (p: heap_predicate{stable p}) : Type0 | val witnessed (p: heap_predicate{stable p}) : Type0 | let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 49,
"start_col": 0,
"start_line": 49
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.heap_predicate{FStar.ST.stable p} -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.heap_predicate",
"FStar.ST.stable",
"FStar.Monotonic.Witnessed.witnessed",
"FStar.Monotonic.Heap.heap",
"FStar.ST.heap_rel"
] | [] | false | false | false | false | true | let witnessed (p: heap_predicate{stable p}) : Type0 =
| W.witnessed heap_rel p | false |
FStar.ST.fst | FStar.ST.read | val read (#a: Type) (#rel: preorder a) (r: mref a rel) : STATE a (fun p h -> p (sel h r) h) | val read (#a: Type) (#rel: preorder a) (r: mref a rel) : STATE a (fun p h -> p (sel h r) h) | let read (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE a (fun p h -> p (sel h r) h)
= let h0 = gst_get () in
gst_recall (contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r;
sel_tot h0 r | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 100,
"start_col": 0,
"start_line": 96
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True)
let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r
type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)}
let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h)
= gst_recall (contains_pred r)
let alloc (#a:Type) (#rel:preorder a) (init:a)
:ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init)
= let h0 = gst_get () in
let r, h1 = alloc rel h0 init false in
gst_put h1;
gst_witness (contains_pred r);
r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.mref a rel -> FStar.ST.STATE a | FStar.ST.STATE | [] | [] | [
"FStar.Preorder.preorder",
"FStar.ST.mref",
"FStar.Monotonic.Heap.sel_tot",
"Prims.unit",
"FStar.Monotonic.Heap.lemma_sel_equals_sel_tot_for_contained_refs",
"FStar.ST.gst_recall",
"FStar.ST.contains_pred",
"FStar.Monotonic.Heap.heap",
"FStar.ST.gst_get",
"FStar.Pervasives.st_post_h",
"FStar.Monotonic.Heap.sel"
] | [] | false | true | false | false | false | let read (#a: Type) (#rel: preorder a) (r: mref a rel) : STATE a (fun p h -> p (sel h r) h) =
| let h0 = gst_get () in
gst_recall (contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r;
sel_tot h0 r | false |
FStar.ST.fst | FStar.ST.alloc | val alloc (#a: Type) (#rel: preorder a) (init: a)
: ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init) | val alloc (#a: Type) (#rel: preorder a) (init: a)
: ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init) | let alloc (#a:Type) (#rel:preorder a) (init:a)
:ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init)
= let h0 = gst_get () in
let r, h1 = alloc rel h0 init false in
gst_put h1;
gst_witness (contains_pred r);
r | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 94,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True)
let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r
type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)}
let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h)
= gst_recall (contains_pred r) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | init: a -> FStar.ST.ST (FStar.ST.mref a rel) | FStar.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.Heap.mref",
"FStar.Monotonic.Heap.heap",
"FStar.ST.mref",
"Prims.unit",
"FStar.ST.gst_witness",
"FStar.ST.contains_pred",
"FStar.ST.gst_put",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Heap.alloc",
"FStar.ST.gst_get",
"Prims.l_True",
"Prims.l_and",
"FStar.Monotonic.Heap.fresh",
"FStar.Monotonic.Heap.modifies",
"FStar.Set.empty",
"Prims.nat",
"Prims.eq2",
"FStar.Monotonic.Heap.sel"
] | [] | false | true | false | false | false | let alloc (#a: Type) (#rel: preorder a) (init: a)
: ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init) =
| let h0 = gst_get () in
let r, h1 = alloc rel h0 init false in
gst_put h1;
gst_witness (contains_pred r);
r | false |
FStar.ST.fst | FStar.ST.recall | val recall (#a: Type) (#rel: preorder a) (r: mref a rel)
: STATE unit (fun p h -> Heap.contains h r ==> p () h) | val recall (#a: Type) (#rel: preorder a) (r: mref a rel)
: STATE unit (fun p h -> Heap.contains h r ==> p () h) | let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h)
= gst_recall (contains_pred r) | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 84,
"start_col": 0,
"start_line": 83
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True)
let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r
type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.mref a rel -> FStar.ST.STATE Prims.unit | FStar.ST.STATE | [] | [] | [
"FStar.Preorder.preorder",
"FStar.ST.mref",
"FStar.ST.gst_recall",
"FStar.ST.contains_pred",
"Prims.unit",
"FStar.Pervasives.st_post_h",
"FStar.Monotonic.Heap.heap",
"Prims.l_imp",
"FStar.Monotonic.Heap.contains"
] | [] | false | true | false | false | false | let recall (#a: Type) (#rel: preorder a) (r: mref a rel)
: STATE unit (fun p h -> Heap.contains h r ==> p () h) =
| gst_recall (contains_pred r) | false |
FStar.ST.fst | FStar.ST.get | val get (u: unit) : ST heap (fun h -> True) (fun h0 h h1 -> h0 == h1 /\ h == h1) | val get (u: unit) : ST heap (fun h -> True) (fun h0 h h1 -> h0 == h1 /\ h == h1) | let get (u:unit) :ST heap (fun h -> True) (fun h0 h h1 -> h0==h1 /\ h==h1) = gst_get () | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 87,
"end_line": 116,
"start_col": 0,
"start_line": 116
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True)
let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r
type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)}
let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h)
= gst_recall (contains_pred r)
let alloc (#a:Type) (#rel:preorder a) (init:a)
:ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init)
= let h0 = gst_get () in
let r, h1 = alloc rel h0 init false in
gst_put h1;
gst_witness (contains_pred r);
r
let read (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE a (fun p h -> p (sel h r) h)
= let h0 = gst_get () in
gst_recall (contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r;
sel_tot h0 r
let write (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\
modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\
sel h1 r == v)
= let h0 = gst_get () in
gst_recall (contains_pred r);
let h1 = upd_tot h0 r v in
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_upd_equals_upd_tot_for_contained_refs h0 r v;
gst_put h1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | u88: Prims.unit -> FStar.ST.ST FStar.Monotonic.Heap.heap | FStar.ST.ST | [] | [] | [
"Prims.unit",
"FStar.ST.gst_get",
"FStar.Monotonic.Heap.heap",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2"
] | [] | false | true | false | false | false | let get (u: unit) : ST heap (fun h -> True) (fun h0 h h1 -> h0 == h1 /\ h == h1) =
| gst_get () | false |
FStar.ST.fst | FStar.ST.op_Colon_Equals | val ( := ) (#a: Type) (#rel: preorder a) (r: mref a rel) (v: a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 ->
rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\
equal_dom h0 h1 /\ sel h1 r == v) | val ( := ) (#a: Type) (#rel: preorder a) (r: mref a rel) (v: a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 ->
rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\
equal_dom h0 h1 /\ sel h1 r == v) | let op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\
modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\
sel h1 r == v)
= write #a #rel r v | {
"file_name": "ulib/FStar.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 128,
"start_col": 0,
"start_line": 122
} | (*
Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, 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.ST
open FStar.TSet
open FStar.Heap
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(***** Global ST (GST) effect with put, get, witness, and recall *****)
new_effect GST = STATE_h heap
let gst_pre = st_pre_h heap
let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre
let gst_post (a:Type) = st_post_h heap a
let gst_wp (a:Type) = st_wp_h heap a
unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h)
sub_effect DIV ~> GST = lift_div_gst
let heap_rel (h1:heap) (h2:heap) =
forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==>
(h2 `contains` r /\ rel (sel h1 r) (sel h2 r))
assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0)
assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1)
type heap_predicate = heap -> Type0
let stable (p:heap_predicate) =
forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2
[@@"opaque_to_smt"]
let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p
assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0))
assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0))
val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p})
(q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)})
:Lemma (ensures (witnessed q))
let lemma_functoriality p q =
reveal_opaque (`%witnessed) witnessed;
W.lemma_witnessed_weakening heap_rel p q
(***** ST effect *****)
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
effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) =
STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1))
effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True)
let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r
type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)}
let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h)
= gst_recall (contains_pred r)
let alloc (#a:Type) (#rel:preorder a) (init:a)
:ST (mref a rel)
(fun h -> True)
(fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init)
= let h0 = gst_get () in
let r, h1 = alloc rel h0 init false in
gst_put h1;
gst_witness (contains_pred r);
r
let read (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE a (fun p h -> p (sel h r) h)
= let h0 = gst_get () in
gst_recall (contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r;
sel_tot h0 r
let write (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\
modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\
sel h1 r == v)
= let h0 = gst_get () in
gst_recall (contains_pred r);
let h1 = upd_tot h0 r v in
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_upd_equals_upd_tot_for_contained_refs h0 r v;
gst_put h1
let get (u:unit) :ST heap (fun h -> True) (fun h0 h h1 -> h0==h1 /\ h==h1) = gst_get ()
let op_Bang (#a:Type) (#rel:preorder a) (r:mref a rel)
: STATE a (fun p h -> p (sel h r) h)
= read #a #rel r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false,
"source_file": "FStar.ST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.TSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": 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.ST.mref a rel -> v: a -> FStar.ST.ST Prims.unit | FStar.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.ST.mref",
"FStar.ST.write",
"Prims.unit",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.Heap.sel",
"Prims.l_and",
"FStar.Monotonic.Heap.contains",
"FStar.Monotonic.Heap.modifies",
"FStar.Set.singleton",
"Prims.nat",
"FStar.Monotonic.Heap.addr_of",
"FStar.Monotonic.Heap.equal_dom",
"Prims.eq2"
] | [] | false | true | false | false | false | let ( := ) (#a: Type) (#rel: preorder a) (r: mref a rel) (v: a)
: ST unit
(fun h -> rel (sel h r) v)
(fun h0 x h1 ->
rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\
equal_dom h0 h1 /\ sel h1 r == v) =
| write #a #rel r v | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.