effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let op_Greater_Greater_Hat = shift_right | let op_Greater_Greater_Hat = | false | null | false | shift_right | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [] | [
"FStar.UInt8.shift_right"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Greater_Greater_Hat : a: FStar.UInt8.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt8.t | [] | FStar.UInt8.op_Greater_Greater_Hat | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt8.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt8.t | {
"end_col": 47,
"end_line": 330,
"start_col": 36,
"start_line": 330
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let op_Less_Less_Hat = shift_left | let op_Less_Less_Hat = | false | null | false | shift_left | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [] | [
"FStar.UInt8.shift_left"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Less_Less_Hat : a: FStar.UInt8.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt8.t | [] | FStar.UInt8.op_Less_Less_Hat | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt8.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt8.t | {
"end_col": 40,
"end_line": 329,
"start_col": 30,
"start_line": 329
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let op_Greater_Equals_Hat = gte | let op_Greater_Equals_Hat = | false | null | false | gte | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [
"total"
] | [
"FStar.UInt8.gte"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | true | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Greater_Equals_Hat : a: FStar.UInt8.t -> b: FStar.UInt8.t -> Prims.bool | [] | FStar.UInt8.op_Greater_Equals_Hat | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt8.t -> b: FStar.UInt8.t -> Prims.bool | {
"end_col": 38,
"end_line": 333,
"start_col": 35,
"start_line": 333
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let n_minus_one = UInt32.uint_to_t (n - 1) | let n_minus_one = | false | null | false | UInt32.uint_to_t (n - 1) | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [
"total"
] | [
"FStar.UInt32.uint_to_t",
"Prims.op_Subtraction",
"FStar.UInt8.n"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | true | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val n_minus_one : FStar.UInt32.t | [] | FStar.UInt8.n_minus_one | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.UInt32.t | {
"end_col": 42,
"end_line": 243,
"start_col": 18,
"start_line": 243
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let minus (a:t) = add_mod (lognot a) (uint_to_t 1) | let minus (a: t) = | false | null | false | add_mod (lognot a) (uint_to_t 1) | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [
"total"
] | [
"FStar.UInt8.t",
"FStar.UInt8.add_mod",
"FStar.UInt8.lognot",
"FStar.UInt8.uint_to_t"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | true | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val minus : a: FStar.UInt8.t -> FStar.UInt8.t | [] | FStar.UInt8.minus | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt8.t -> FStar.UInt8.t | {
"end_col": 50,
"end_line": 239,
"start_col": 18,
"start_line": 239
} | |
Prims.Pure | val gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let gte_mask (a:t) (b:t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\
(v a < v b ==> v c = 0)))
= let x = a in
let y = b in
let x_xor_y = logxor x y in
let x_sub_y = sub_mod x y in
let x_sub_y_xor_y = logxor x_sub_y y in
let q = ... | val gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0)))
let gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0))) = | false | null | false | let x = a in
let y = b in
let x_xor_y = logxor x y in
let x_sub_y = sub_mod x y in
let x_sub_y_xor_y = logxor x_sub_y y in
let q = logor x_xor_y x_sub_y_xor_y in
let x_xor_q = logxor x q in
let x_xor_q_ = shift_right x_xor_q n_minus_one in
let c = sub_mod x_xor_q_ (uint_to_t 1) in
lemma_sub_msbs x y;
lemma_msb_gte (v x... | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [] | [
"FStar.UInt8.t",
"Prims.unit",
"FStar.UInt.lemma_msb_gte",
"FStar.UInt8.n",
"FStar.UInt8.v",
"FStar.UInt8.lemma_sub_msbs",
"FStar.UInt8.sub_mod",
"FStar.UInt8.uint_to_t",
"FStar.UInt8.shift_right",
"FStar.UInt8.n_minus_one",
"FStar.UInt8.logxor",
"FStar.UInt8.logor",
"Prims.l_True",
"Prims... | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"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_el... | null | val gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0))) | [] | FStar.UInt8.gte_mask | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt8.t -> b: FStar.UInt8.t -> Prims.Pure FStar.UInt8.t | {
"end_col": 5,
"end_line": 311,
"start_col": 3,
"start_line": 299
} |
Prims.Pure | val eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt"... | false | let eq_mask (a:t) (b:t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\
(v a <> v b ==> v c = 0)))
= let x = logxor a b in
let minus_x = minus x in
let x_or_minus_x = logor x minus_x in
let xnx = shift_right x_or_minus_x n_minus_one in
l... | val eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0)))
let eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0))) = | false | null | false | let x = logxor a b in
let minus_x = minus x in
let x_or_minus_x = logor x minus_x in
let xnx = shift_right x_or_minus_x n_minus_one in
let c = sub_mod xnx (uint_to_t 1) in
if a = b
then
(logxor_self (v a);
lognot_lemma_1 #n;
logor_lemma_1 (v x);
assert (v x = 0 /\ v minus_x = 0 /\ v x_or_minus_x = 0 /\ v ... | {
"checked_file": "FStar.UInt8.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt8.fsti"
} | [] | [
"FStar.UInt8.t",
"Prims.unit",
"Prims.op_Equality",
"Prims._assert",
"Prims.b2t",
"FStar.UInt.uint_t",
"FStar.UInt8.n",
"FStar.UInt8.v",
"FStar.UInt.ones",
"Prims.l_and",
"Prims.int",
"FStar.UInt.logor_lemma_1",
"FStar.UInt.lognot_lemma_1",
"FStar.UInt.logxor_self",
"Prims.bool",
"FSta... | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.UInt8.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"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_el... | null | val eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0))) | [] | FStar.UInt8.eq_mask | {
"file_name": "ulib/FStar.UInt8.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt8.t -> b: FStar.UInt8.t -> Prims.Pure FStar.UInt8.t | {
"end_col": 5,
"end_line": 282,
"start_col": 3,
"start_line": 260
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let bytes = Seq.seq uint8 | let bytes = | false | null | false | Seq.seq uint8 | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"FStar.Seq.Base.seq",
"Spec.Agile.AEAD.uint8"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bytes : Type0 | [] | EverCrypt.AEAD.bytes | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 25,
"end_line": 129,
"start_col": 12,
"start_line": 129
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let freeable (#a: alg) (h: HS.mem) (p: state a) =
B.freeable p /\ freeable_s (B.deref h p) | let freeable (#a: alg) (h: HS.mem) (p: state a) = | false | null | false | B.freeable p /\ freeable_s (B.deref h p) | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"FStar.Monotonic.HyperStack.mem",
"EverCrypt.AEAD.state",
"Prims.l_and",
"LowStar.Monotonic.Buffer.freeable",
"EverCrypt.AEAD.state_s",
"LowStar.Buffer.trivial_preorder",
"EverCrypt.AEAD.freeable_s",
"LowStar.Monotonic.Buffer.deref",
"Prims.logical"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val freeable : h: FStar.Monotonic.HyperStack.mem -> p: EverCrypt.AEAD.state a -> Prims.logical | [] | EverCrypt.AEAD.freeable | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: EverCrypt.AEAD.state a -> Prims.logical | {
"end_col": 42,
"end_line": 54,
"start_col": 2,
"start_line": 54
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let state alg = B.pointer (state_s alg) | let state alg = | false | null | false | B.pointer (state_s alg) | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"LowStar.Buffer.pointer",
"EverCrypt.AEAD.state_s"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val state : alg: Spec.Agile.AEAD.alg -> Type0 | [] | EverCrypt.AEAD.state | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | alg: Spec.Agile.AEAD.alg -> Type0 | {
"end_col": 39,
"end_line": 47,
"start_col": 16,
"start_line": 47
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let ad_p a = ad:B.buffer uint8 { B.length ad <= max_length a } | let ad_p a = | false | null | false | ad: B.buffer uint8 {B.length ad <= max_length a} | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Spec.Agile.AEAD.max_length"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ad_p : a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.ad_p | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 62,
"end_line": 234,
"start_col": 13,
"start_line": 234
} | |
Prims.Tot | val preserves_freeable (#a: _) (s: state a) (h0 h1: HS.mem) : Type0 | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let preserves_freeable #a (s: state a) (h0 h1: HS.mem): Type0 =
freeable h0 s ==> freeable h1 s | val preserves_freeable (#a: _) (s: state a) (h0 h1: HS.mem) : Type0
let preserves_freeable #a (s: state a) (h0: HS.mem) (h1: HS.mem) : Type0 = | false | null | false | freeable h0 s ==> freeable h1 s | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"EverCrypt.AEAD.state",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"EverCrypt.AEAD.freeable"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val preserves_freeable (#a: _) (s: state a) (h0 h1: HS.mem) : Type0 | [] | EverCrypt.AEAD.preserves_freeable | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: EverCrypt.AEAD.state a ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> Type0 | {
"end_col": 33,
"end_line": 58,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let plain_p a = p:B.buffer uint8 { B.length p <= max_length a } | let plain_p a = | false | null | false | p: B.buffer uint8 {B.length p <= max_length a} | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Spec.Agile.AEAD.max_length"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val plain_p : a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.plain_p | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 63,
"end_line": 237,
"start_col": 16,
"start_line": 237
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let config_pre a =
match a with
| AES128_GCM
| AES256_GCM ->
EverCrypt.TargetConfig.hacl_can_compile_vale /\
Vale.X64.CPU_Features_s.(aesni_enabled /\ pclmulqdq_enabled /\ avx_enabled /\
movbe_enabled /\ sse_enabled)
| CHACHA20_POLY1305 -> True
| _ -> True | let config_pre a = | false | null | false | match a with
| AES128_GCM
| AES256_GCM ->
EverCrypt.TargetConfig.hacl_can_compile_vale /\
Vale.X64.CPU_Features_s.(aesni_enabled /\ pclmulqdq_enabled /\ avx_enabled /\ movbe_enabled /\
sse_enabled)
| CHACHA20_POLY1305 -> True
| _ -> True | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"Prims.l_and",
"Prims.b2t",
"EverCrypt.TargetConfig.hacl_can_compile_vale",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.pclmulqdq_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.X64.CPU_Features_s.movbe_enabled",
"Vale.X64.CPU_Features_s.sse_enable... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val config_pre : a: Spec.Agile.AEAD.alg -> Prims.logical | [] | EverCrypt.AEAD.config_pre | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.alg -> Prims.logical | {
"end_col": 13,
"end_line": 94,
"start_col": 2,
"start_line": 87
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let cipher_p a = p:B.buffer uint8 { B.length p + tag_length a <= max_length a } | let cipher_p a = | false | null | false | p: B.buffer uint8 {B.length p + tag_length a <= max_length a} | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"Prims.b2t",
"Spec.Agile.AEAD.is_supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Integers.op_Plus",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_pre... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val cipher_p : a: Spec.Agile.AEAD.alg{Spec.Agile.AEAD.is_supported_alg a} -> Type0 | [] | EverCrypt.AEAD.cipher_p | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.alg{Spec.Agile.AEAD.is_supported_alg a} -> Type0 | {
"end_col": 79,
"end_line": 240,
"start_col": 17,
"start_line": 240
} | |
Prims.GTot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let footprint (#a:alg) (m: HS.mem) (s: state a) =
B.(loc_union (loc_addr_of_buffer s) (footprint_s (B.deref m s))) | let footprint (#a: alg) (m: HS.mem) (s: state a) = | false | null | false | let open B in loc_union (loc_addr_of_buffer s) (footprint_s (B.deref m s)) | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"sometrivial"
] | [
"Spec.Agile.AEAD.alg",
"FStar.Monotonic.HyperStack.mem",
"EverCrypt.AEAD.state",
"LowStar.Monotonic.Buffer.loc_union",
"LowStar.Monotonic.Buffer.loc_addr_of_buffer",
"EverCrypt.AEAD.state_s",
"LowStar.Buffer.trivial_preorder",
"EverCrypt.AEAD.footprint_s",
"LowStar.Monotonic.Buffer.deref",
"LowSta... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val footprint : m: FStar.Monotonic.HyperStack.mem -> s: EverCrypt.AEAD.state a
-> Prims.GTot LowStar.Monotonic.Buffer.loc | [] | EverCrypt.AEAD.footprint | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: FStar.Monotonic.HyperStack.mem -> s: EverCrypt.AEAD.state a
-> Prims.GTot LowStar.Monotonic.Buffer.loc | {
"end_col": 66,
"end_line": 62,
"start_col": 2,
"start_line": 62
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let iv_p a = iv:B.buffer uint8 { iv_length a (B.length iv)} | let iv_p a = | false | null | false | iv: B.buffer uint8 {iv_length a (B.length iv)} | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Spec.Agile.AEAD.iv_length",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder"
] | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val iv_p : a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.iv_p | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 59,
"end_line": 231,
"start_col": 13,
"start_line": 231
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let encrypt_live_disjoint_pre (a: supported_alg)
(iv:iv_p a)
(iv_len: UInt32.t)
(ad:ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher: B.buffer uint8)
(tag: B.buffer uint8)
(h0: HS.mem)
=
MB.(all_live h0 [ buf iv; buf ad; buf plain; buf cipher; buf tag ]) /\
(B.disjoint p... | let encrypt_live_disjoint_pre
(a: supported_alg)
(iv: iv_p a)
(iv_len: UInt32.t)
(ad: ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher tag: B.buffer uint8)
(h0: HS.mem)
= | false | null | false | MB.(all_live h0 [buf iv; buf ad; buf plain; buf cipher; buf tag]) /\
(B.disjoint plain cipher \/ plain == cipher) /\ B.disjoint cipher tag /\ B.disjoint iv cipher /\
B.disjoint iv tag /\ B.disjoint plain tag /\ B.disjoint plain ad /\ B.disjoint ad cipher /\
B.disjoint ad tag | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"EverCrypt.AEAD.iv_p",
"FStar.UInt32.t",
"EverCrypt.AEAD.ad_p",
"EverCrypt.AEAD.plain_p",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.all_live",
"Prims.Cons",
"LowStar.Monotonic.Bu... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_live_disjoint_pre : a: Spec.Agile.AEAD.supported_alg ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCrypt.AEAD.plain_p a ->
plain_len: FStar.UInt32.t ->
cipher: LowStar.Buffer.buffer Spec.Agile.AEAD.uint... | [] | EverCrypt.AEAD.encrypt_live_disjoint_pre | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Agile.AEAD.supported_alg ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCrypt.AEAD.plain_p a ->
plain_len: FStar.UInt32.t ->
cipher: LowStar.Buffer.buffer Spec.Agile.AEAD.uint8 ->
tag: LowStar.Buffe... | {
"end_col": 43,
"end_line": 279,
"start_col": 2,
"start_line": 273
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let alloca_st (a: alg) =
k:B.buffer uint8 { B.length k = key_length a } ->
StackInline (B.pointer (state_s a))
(requires fun h0 ->
B.live h0 k /\ config_pre a /\ is_supported_alg a)
(ensures fun h0 s h1 ->
// Sanity
invariant h1 s /\
// Memory stuff
B.(modifies loc_none h0 h1)... | let alloca_st (a: alg) = | false | null | false | k: B.buffer uint8 {B.length k = key_length a}
-> StackInline (B.pointer (state_s a))
(requires fun h0 -> B.live h0 k /\ config_pre a /\ is_supported_alg a)
(ensures
fun h0 s h1 ->
invariant h1 s /\ B.(modifies loc_none h0 h1) /\ B.fresh_loc (footprint h1 s) h0 h1 /\
B.live h1 s... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.op_Greater_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monotonic.Buffer.length",
"Lo... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val alloca_st : a: Spec.Agile.AEAD.alg -> Type0 | [] | EverCrypt.AEAD.alloca_st | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.alg -> Type0 | {
"end_col": 44,
"end_line": 197,
"start_col": 2,
"start_line": 182
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let encrypt_expand_pre (a: supported_alg)
(k:B.buffer uint8 { B.length k = key_length a })
(iv:iv_p a)
(iv_len: UInt32.t)
(ad:ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher: B.buffer uint8)
(tag: B.buffer uint8)
(h0: HS.mem)
=
encrypt_gen_pre a iv iv_len ad ad_len plai... | let encrypt_expand_pre
(a: supported_alg)
(k: B.buffer uint8 {B.length k = key_length a})
(iv: iv_p a)
(iv_len: UInt32.t)
(ad: ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher tag: B.buffer uint8)
(h0: HS.mem)
= | false | null | false | encrypt_gen_pre a iv iv_len ad ad_len plain plain_len cipher tag h0 /\
(B.live h0 k /\ B.disjoint k cipher /\
encrypt_live_disjoint_pre a iv iv_len ad ad_len plain plain_len cipher tag h0) | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.op_Greater_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monotonic.Buffer.leng... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_expand_pre : a: Spec.Agile.AEAD.supported_alg ->
k:
LowStar.Buffer.buffer Spec.Agile.AEAD.uint8
{LowStar.Monotonic.Buffer.length k = Spec.Agile.AEAD.key_length a} ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t -... | [] | EverCrypt.AEAD.encrypt_expand_pre | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Agile.AEAD.supported_alg ->
k:
LowStar.Buffer.buffer Spec.Agile.AEAD.uint8
{LowStar.Monotonic.Buffer.length k = Spec.Agile.AEAD.key_length a} ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCry... | {
"end_col": 58,
"end_line": 383,
"start_col": 2,
"start_line": 380
} | |
FStar.Pervasives.Lemma | val loc_includes_union_l_footprint_s (l1 l2: B.loc) (#a: alg) (s: state_s a)
: Lemma (requires (B.loc_includes l1 (footprint_s s) \/ B.loc_includes l2 (footprint_s s)))
(ensures (B.loc_includes (B.loc_union l1 l2) (footprint_s s)))
[SMTPat (B.loc_includes (B.loc_union l1 l2) (footprint_s s))] | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let loc_includes_union_l_footprint_s
(l1 l2: B.loc) (#a: alg) (s: state_s a)
: Lemma
(requires (
B.loc_includes l1 (footprint_s s) \/ B.loc_includes l2 (footprint_s s)
))
(ensures (B.loc_includes (B.loc_union l1 l2) (footprint_s s)))
[SMTPat (B.loc_includes (B.loc_union l1 l2) (footprint_s s))]
= B.loc_in... | val loc_includes_union_l_footprint_s (l1 l2: B.loc) (#a: alg) (s: state_s a)
: Lemma (requires (B.loc_includes l1 (footprint_s s) \/ B.loc_includes l2 (footprint_s s)))
(ensures (B.loc_includes (B.loc_union l1 l2) (footprint_s s)))
[SMTPat (B.loc_includes (B.loc_union l1 l2) (footprint_s s))]
let loc_in... | false | null | true | B.loc_includes_union_l l1 l2 (footprint_s s) | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"lemma"
] | [
"LowStar.Monotonic.Buffer.loc",
"Spec.Agile.AEAD.alg",
"EverCrypt.AEAD.state_s",
"LowStar.Monotonic.Buffer.loc_includes_union_l",
"EverCrypt.AEAD.footprint_s",
"Prims.unit",
"Prims.l_or",
"LowStar.Monotonic.Buffer.loc_includes",
"Prims.squash",
"LowStar.Monotonic.Buffer.loc_union",
"Prims.Cons",... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val loc_includes_union_l_footprint_s (l1 l2: B.loc) (#a: alg) (s: state_s a)
: Lemma (requires (B.loc_includes l1 (footprint_s s) \/ B.loc_includes l2 (footprint_s s)))
(ensures (B.loc_includes (B.loc_union l1 l2) (footprint_s s)))
[SMTPat (B.loc_includes (B.loc_union l1 l2) (footprint_s s))] | [] | EverCrypt.AEAD.loc_includes_union_l_footprint_s | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | l1: LowStar.Monotonic.Buffer.loc -> l2: LowStar.Monotonic.Buffer.loc -> s: EverCrypt.AEAD.state_s a
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes l1 (EverCrypt.AEAD.footprint_s s) \/
LowStar.Monotonic.Buffer.loc_includes l2 (EverCrypt.AEAD.footprint_s s))
(ensur... | {
"end_col": 46,
"end_line": 82,
"start_col": 2,
"start_line": 82
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let invariant (#a:alg) (m: HS.mem) (s: state a) =
B.live m s /\
B.(loc_disjoint (loc_addr_of_buffer s) (footprint_s (B.deref m s))) /\
invariant_s m (B.get m s 0) | let invariant (#a: alg) (m: HS.mem) (s: state a) = | false | null | false | B.live m s /\ B.(loc_disjoint (loc_addr_of_buffer s) (footprint_s (B.deref m s))) /\
invariant_s m (B.get m s 0) | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"FStar.Monotonic.HyperStack.mem",
"EverCrypt.AEAD.state",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"EverCrypt.AEAD.state_s",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowStar.Monotonic.Buffer.loc_addr_of_buffer",
"EverCrypt.AEAD.foot... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val invariant : m: FStar.Monotonic.HyperStack.mem -> s: EverCrypt.AEAD.state a -> Prims.logical | [] | EverCrypt.AEAD.invariant | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: FStar.Monotonic.HyperStack.mem -> s: EverCrypt.AEAD.state a -> Prims.logical | {
"end_col": 29,
"end_line": 103,
"start_col": 2,
"start_line": 101
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let encrypt_gen_pre (a: supported_alg)
(iv:iv_p a)
(iv_len: UInt32.t)
(ad:ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher: B.buffer uint8)
(tag: B.buffer uint8)
(h0: HS.mem)
=
v iv_len = B.length iv /\ v iv_len > 0 /\
v ad_len = B.length ad /\ v ad_len <= pow2 31 /\
v... | let encrypt_gen_pre
(a: supported_alg)
(iv: iv_p a)
(iv_len: UInt32.t)
(ad: ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher tag: B.buffer uint8)
(h0: HS.mem)
= | false | null | false | v iv_len = B.length iv /\ v iv_len > 0 /\ v ad_len = B.length ad /\ v ad_len <= pow2 31 /\
v plain_len = B.length plain /\ v plain_len <= max_length a /\ B.length cipher = B.length plain /\
B.length tag = tag_length a | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"EverCrypt.AEAD.iv_p",
"FStar.UInt32.t",
"EverCrypt.AEAD.ad_p",
"EverCrypt.AEAD.plain_p",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_gen_pre : a: Spec.Agile.AEAD.supported_alg ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCrypt.AEAD.plain_p a ->
plain_len: FStar.UInt32.t ->
cipher: LowStar.Buffer.buffer Spec.Agile.AEAD.uint8 ->
t... | [] | EverCrypt.AEAD.encrypt_gen_pre | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Agile.AEAD.supported_alg ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCrypt.AEAD.plain_p a ->
plain_len: FStar.UInt32.t ->
cipher: LowStar.Buffer.buffer Spec.Agile.AEAD.uint8 ->
tag: LowStar.Buffe... | {
"end_col": 29,
"end_line": 259,
"start_col": 2,
"start_line": 255
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let create_in_st (a: alg) =
r:HS.rid ->
dst:B.pointer (B.pointer_or_null (state_s a)) ->
k:B.buffer uint8 { B.length k = key_length a } ->
ST error_code
(requires fun h0 ->
ST.is_eternal_region r /\
B.live h0 k /\ B.live h0 dst)
(ensures fun h0 e h1 ->
match e with
| UnsupportedA... | let create_in_st (a: alg) = | false | null | false |
r: HS.rid ->
dst: B.pointer (B.pointer_or_null (state_s a)) ->
k: B.buffer uint8 {B.length k = key_length a}
-> ST error_code
(requires fun h0 -> ST.is_eternal_region r /\ B.live h0 k /\ B.live h0 dst)
(ensures
fun h0 e h1 ->
match e with
| UnsupportedAlgorithm -> ... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.alg",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Buffer.pointer",
"LowStar.Buffer.pointer_or_null",
"EverCrypt.AEAD.state_s",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.I... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val create_in_st : a: Spec.Agile.AEAD.alg -> Type0 | [] | EverCrypt.AEAD.create_in_st | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.alg -> Type0 | {
"end_col": 19,
"end_line": 174,
"start_col": 2,
"start_line": 148
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let encrypt_pre (a: supported_alg)
(s:B.pointer_or_null (state_s a))
(iv:iv_p a)
(iv_len: UInt32.t)
(ad:ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher: B.buffer uint8)
(tag: B.buffer uint8)
(h0: HS.mem)
=
encrypt_gen_pre a iv iv_len ad ad_len plain plain_len cipher tag... | let encrypt_pre
(a: supported_alg)
(s: B.pointer_or_null (state_s a))
(iv: iv_p a)
(iv_len: UInt32.t)
(ad: ad_p a)
(ad_len: UInt32.t)
(plain: plain_p a)
(plain_len: UInt32.t)
(cipher tag: B.buffer uint8)
(h0: HS.mem)
= | false | null | false | encrypt_gen_pre a iv iv_len ad ad_len plain plain_len cipher tag h0 /\
(not (B.g_is_null s) ==>
invariant h0 s /\ B.(loc_disjoint (footprint h0 s) (loc_buffer iv)) /\
B.(loc_disjoint (footprint h0 s) (loc_buffer ad)) /\
B.(loc_disjoint (footprint h0 s) (loc_buffer tag)) /\
B.(loc_disjoint (footprint h0 s) (loc_... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.pointer_or_null",
"EverCrypt.AEAD.state_s",
"EverCrypt.AEAD.iv_p",
"FStar.UInt32.t",
"EverCrypt.AEAD.ad_p",
"EverCrypt.AEAD.plain_p",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"EverCrypt.A... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | false | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_pre : a: Spec.Agile.AEAD.supported_alg ->
s: LowStar.Buffer.pointer_or_null (EverCrypt.AEAD.state_s a) ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCrypt.AEAD.plain_p a ->
plain_len: FStar.UInt32.t ->
... | [] | EverCrypt.AEAD.encrypt_pre | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Agile.AEAD.supported_alg ->
s: LowStar.Buffer.pointer_or_null (EverCrypt.AEAD.state_s a) ->
iv: EverCrypt.AEAD.iv_p a ->
iv_len: FStar.UInt32.t ->
ad: EverCrypt.AEAD.ad_p a ->
ad_len: FStar.UInt32.t ->
plain: EverCrypt.AEAD.plain_p a ->
plain_len: FStar.UInt32.t ->
cipher: L... | {
"end_col": 82,
"end_line": 302,
"start_col": 2,
"start_line": 294
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let encrypt_expand_st (does_runtime_check: bool) (a: supported_alg) =
k:B.buffer uint8 { B.length k = key_length a } ->
iv:iv_p a ->
iv_len: UInt32.t { v iv_len = B.length iv /\ v iv_len > 0 } ->
ad:ad_p a ->
ad_len: UInt32.t { v ad_len = B.length ad /\ v ad_len <= pow2 31 } ->
plain: plain_p a ->
plain_l... | let encrypt_expand_st (does_runtime_check: bool) (a: supported_alg) = | false | null | false |
k: B.buffer uint8 {B.length k = key_length a} ->
iv: iv_p a ->
iv_len: UInt32.t{v iv_len = B.length iv /\ v iv_len > 0} ->
ad: ad_p a ->
ad_len: UInt32.t{v ad_len = B.length ad /\ v ad_len <= pow2 31} ->
plain: plain_p a ->
plain_len: UInt32.t{v plain_len = B.length plain /\ v plain_len <= ... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Prims.bool",
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.op_Greater_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monot... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_expand_st : does_runtime_check: Prims.bool -> a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.encrypt_expand_st | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | does_runtime_check: Prims.bool -> a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 16,
"end_line": 415,
"start_col": 2,
"start_line": 387
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let encrypt_st (a: supported_alg) =
s:B.pointer_or_null (state_s a) ->
iv:iv_p a ->
iv_len: UInt32.t { v iv_len = B.length iv /\ v iv_len > 0 } ->
ad:ad_p a ->
ad_len: UInt32.t { v ad_len = B.length ad /\ v ad_len <= pow2 31 } ->
plain: plain_p a ->
plain_len: UInt32.t { v plain_len = B.length plain /\ v ... | let encrypt_st (a: supported_alg) = | false | null | false |
s: B.pointer_or_null (state_s a) ->
iv: iv_p a ->
iv_len: UInt32.t{v iv_len = B.length iv /\ v iv_len > 0} ->
ad: ad_p a ->
ad_len: UInt32.t{v ad_len = B.length ad /\ v ad_len <= pow2 31} ->
plain: plain_p a ->
plain_len: UInt32.t{v plain_len = B.length plain /\ v plain_len <= max_length a}... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.pointer_or_null",
"EverCrypt.AEAD.state_s",
"EverCrypt.AEAD.iv_p",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.within_bounds",
"FStar.Integers.Uns... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_st : a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.encrypt_st | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 19,
"end_line": 333,
"start_col": 2,
"start_line": 308
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let decrypt_expand_st (does_runtime_check: bool) (a: supported_alg) =
k:B.buffer uint8 { B.length k = key_length a } ->
iv:iv_p a ->
iv_len:UInt32.t { v iv_len = B.length iv /\ v iv_len > 0 } ->
ad:ad_p a ->
ad_len: UInt32.t { v ad_len = B.length ad /\ v ad_len <= pow2 31 } ->
cipher: cipher_p a ->
cipher... | let decrypt_expand_st (does_runtime_check: bool) (a: supported_alg) = | false | null | false |
k: B.buffer uint8 {B.length k = key_length a} ->
iv: iv_p a ->
iv_len: UInt32.t{v iv_len = B.length iv /\ v iv_len > 0} ->
ad: ad_p a ->
ad_len: UInt32.t{v ad_len = B.length ad /\ v ad_len <= pow2 31} ->
cipher: cipher_p a ->
cipher_len: UInt32.t{v cipher_len = B.length cipher} ->
tag: ... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Prims.bool",
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.buffer",
"Spec.Agile.AEAD.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.op_Greater_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monot... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val decrypt_expand_st : does_runtime_check: Prims.bool -> a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.decrypt_expand_st | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | does_runtime_check: Prims.bool -> a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 10,
"end_line": 586,
"start_col": 2,
"start_line": 549
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "EverCrypt.Error",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "Spec"
},
{
"abbrev": false,
"full_module": "Spec.Agile.AEAD",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let decrypt_st (a: supported_alg) =
s:B.pointer_or_null (state_s a) ->
iv:iv_p a ->
iv_len:UInt32.t { v iv_len = B.length iv /\ v iv_len > 0 } ->
ad:ad_p a ->
ad_len: UInt32.t { v ad_len = B.length ad /\ v ad_len <= pow2 31 } ->
cipher: cipher_p a ->
cipher_len: UInt32.t { v cipher_len = B.length cipher }... | let decrypt_st (a: supported_alg) = | false | null | false |
s: B.pointer_or_null (state_s a) ->
iv: iv_p a ->
iv_len: UInt32.t{v iv_len = B.length iv /\ v iv_len > 0} ->
ad: ad_p a ->
ad_len: UInt32.t{v ad_len = B.length ad /\ v ad_len <= pow2 31} ->
cipher: cipher_p a ->
cipher_len: UInt32.t{v cipher_len = B.length cipher} ->
tag: B.buffer uint... | {
"checked_file": "EverCrypt.AEAD.fsti.checked",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
... | [
"total"
] | [
"Spec.Agile.AEAD.supported_alg",
"LowStar.Buffer.pointer_or_null",
"EverCrypt.AEAD.state_s",
"EverCrypt.AEAD.iv_p",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.within_bounds",
"FStar.Integers.Uns... | [] | module EverCrypt.AEAD
/// The new AEAD interface for EverCrypt, which supersedes the functions found
/// in EverCrypt.fst
///
/// The expected usage for this module is as follows:
/// - client expands key, obtaining an ``expanded_key a``
/// - client uses ``encrypt``/``decrypt`` with the same ``expanded_key a`` repeat... | false | true | EverCrypt.AEAD.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val decrypt_st : a: Spec.Agile.AEAD.supported_alg -> Type0 | [] | EverCrypt.AEAD.decrypt_st | {
"file_name": "providers/evercrypt/EverCrypt.AEAD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.AEAD.supported_alg -> Type0 | {
"end_col": 16,
"end_line": 502,
"start_col": 2,
"start_line": 454
} | |
Prims.Tot | val openBase: openBase_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
... | false | let openBase = hpke_openBase_higher #cs vale_p IAEAD.aead_decrypt_cp256 setupBaseR | val openBase: openBase_st cs vale_p
let openBase = | false | null | false | hpke_openBase_higher #cs vale_p IAEAD.aead_decrypt_cp256 setupBaseR | {
"checked_file": "Hacl.HPKE.Curve64_CP256_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.H... | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_openBase_higher",
"Hacl.HPKE.Curve64_CP256_SHA256.cs",
"Hacl.HPKE.Curve64_CP256_SHA256.vale_p",
"Hacl.HPKE.Interface.AEAD.aead_decrypt_cp256",
"Hacl.HPKE.Curve64_CP256_SHA256.setupBaseR"
] | [] | module Hacl.HPKE.Curve64_CP256_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0"
let setupBaseS = hpke_setupBaseS_higher #cs val... | false | true | Hacl.HPKE.Curve64_CP256_SHA256.fst | {
"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_el... | null | val openBase: openBase_st cs vale_p | [] | Hacl.HPKE.Curve64_CP256_SHA256.openBase | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP256_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.openBase_st Hacl.HPKE.Curve64_CP256_SHA256.cs Hacl.HPKE.Curve64_CP256_SHA256.vale_p | {
"end_col": 82,
"end_line": 20,
"start_col": 15,
"start_line": 20
} |
Prims.Tot | val sealBase: sealBase_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
... | false | let sealBase = hpke_sealBase_higher #cs vale_p IAEAD.aead_encrypt_cp256 setupBaseS | val sealBase: sealBase_st cs vale_p
let sealBase = | false | null | false | hpke_sealBase_higher #cs vale_p IAEAD.aead_encrypt_cp256 setupBaseS | {
"checked_file": "Hacl.HPKE.Curve64_CP256_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.H... | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_sealBase_higher",
"Hacl.HPKE.Curve64_CP256_SHA256.cs",
"Hacl.HPKE.Curve64_CP256_SHA256.vale_p",
"Hacl.HPKE.Interface.AEAD.aead_encrypt_cp256",
"Hacl.HPKE.Curve64_CP256_SHA256.setupBaseS"
] | [] | module Hacl.HPKE.Curve64_CP256_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0"
let setupBaseS = hpke_setupBaseS_higher #cs val... | false | true | Hacl.HPKE.Curve64_CP256_SHA256.fst | {
"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_el... | null | val sealBase: sealBase_st cs vale_p | [] | Hacl.HPKE.Curve64_CP256_SHA256.sealBase | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP256_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.sealBase_st Hacl.HPKE.Curve64_CP256_SHA256.cs Hacl.HPKE.Curve64_CP256_SHA256.vale_p | {
"end_col": 82,
"end_line": 18,
"start_col": 15,
"start_line": 18
} |
Prims.Tot | val setupBaseS: setupBaseS_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
... | false | let setupBaseS = hpke_setupBaseS_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 | val setupBaseS: setupBaseS_st cs vale_p
let setupBaseS = | false | null | false | hpke_setupBaseS_higher #cs
vale_p
IHK.hkdf_expand256
IHK.hkdf_extract256
IDH.secret_to_public_c64
IDH.dh_c64
IHK.hkdf_expand256
IHK.hkdf_extract256 | {
"checked_file": "Hacl.HPKE.Curve64_CP256_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.H... | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_setupBaseS_higher",
"Hacl.HPKE.Curve64_CP256_SHA256.cs",
"Hacl.HPKE.Curve64_CP256_SHA256.vale_p",
"Hacl.HPKE.Interface.HKDF.hkdf_expand256",
"Hacl.HPKE.Interface.HKDF.hkdf_extract256",
"Hacl.HPKE.Interface.DH.secret_to_public_c64",
"Hacl.HPKE.Interface.DH.dh_c64"
] | [] | module Hacl.HPKE.Curve64_CP256_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0" | false | true | Hacl.HPKE.Curve64_CP256_SHA256.fst | {
"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_el... | null | val setupBaseS: setupBaseS_st cs vale_p | [] | Hacl.HPKE.Curve64_CP256_SHA256.setupBaseS | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP256_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.setupBaseS_st Hacl.HPKE.Curve64_CP256_SHA256.cs Hacl.HPKE.Curve64_CP256_SHA256.vale_p | {
"end_col": 164,
"end_line": 14,
"start_col": 17,
"start_line": 14
} |
Prims.Tot | val setupBaseR: setupBaseR_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
... | false | let setupBaseR = hpke_setupBaseR_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 | val setupBaseR: setupBaseR_st cs vale_p
let setupBaseR = | false | null | false | hpke_setupBaseR_higher #cs
vale_p
IHK.hkdf_expand256
IHK.hkdf_extract256
IDH.dh_c64
IHK.hkdf_expand256
IHK.hkdf_extract256
IDH.secret_to_public_c64 | {
"checked_file": "Hacl.HPKE.Curve64_CP256_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.H... | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_setupBaseR_higher",
"Hacl.HPKE.Curve64_CP256_SHA256.cs",
"Hacl.HPKE.Curve64_CP256_SHA256.vale_p",
"Hacl.HPKE.Interface.HKDF.hkdf_expand256",
"Hacl.HPKE.Interface.HKDF.hkdf_extract256",
"Hacl.HPKE.Interface.DH.dh_c64",
"Hacl.HPKE.Interface.DH.secret_to_public_c64"
] | [] | module Hacl.HPKE.Curve64_CP256_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0"
let setupBaseS = hpke_setupBaseS_higher #cs val... | false | true | Hacl.HPKE.Curve64_CP256_SHA256.fst | {
"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_el... | null | val setupBaseR: setupBaseR_st cs vale_p | [] | Hacl.HPKE.Curve64_CP256_SHA256.setupBaseR | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP256_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.setupBaseR_st Hacl.HPKE.Curve64_CP256_SHA256.cs Hacl.HPKE.Curve64_CP256_SHA256.vale_p | {
"end_col": 164,
"end_line": 16,
"start_col": 17,
"start_line": 16
} |
Prims.Tot | val parse32_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata sz p)) | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata sz p))
= parse32_vldata_gen sz (unconstrained_bounded_integer sz) (fun _ -> true) p32 | val parse32_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata sz p))
let parse32_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (pars... | false | null | false | parse32_vldata_gen sz (unconstrained_bounded_integer sz) (fun _ -> true) p32 | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.VLData.parse32_vldata_gen",
"LowParse.Spec.VLData.unconstrained_bounded_integer",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.bool",
"Prims.eq2... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata sz p)) | [] | LowParse.SLow.VLData.parse32_vldata | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | sz: LowParse.Spec.BoundedInt.integer_size -> p32: LowParse.SLow.Base.parser32 p
-> LowParse.SLow.Base.parser32 (LowParse.Spec.VLData.parse_vldata sz p) | {
"end_col": 78,
"end_line": 50,
"start_col": 2,
"start_line": 50
} |
Prims.Tot | val parse32_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(i: bounded_integer sz {f i == true})
: Tot (parser32 (parse_vldata_payload sz f p i)) | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(i: bounded_integer sz { f i == true } )
: Tot (parser32 (parse_vldata_payload sz f p i))
= fun (input: bytes32) -> parse32_fldata p32 (U32.v i) i input | val parse32_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(i: bounded_integer sz {f i == true})
: Tot (parser32 (parse_vldata_payload sz f p i))
let parse32_vldata_payload
(sz: ... | false | null | false | fun (input: bytes32) -> parse32_fldata p32 (U32.v i) i input | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.bool",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"Prims.eq2",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.FLData.parse32_fldata",
"FStar.UInt32.v",
"FS... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(i: bounded_integer sz {f i == true})
: Tot (parser32 (parse_vldata_payload sz f p i)) | [] | LowParse.SLow.VLData.parse32_vldata_payload | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: LowParse.Spec.BoundedInt.integer_size ->
f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) ->
p32: LowParse.SLow.Base.parser32 p ->
i: LowParse.Spec.BoundedInt.bounded_integer sz {f i == true}
-> LowParse.SLow.Base.parser32 (LowParse.Spec.VLData.parse_vldata_payload sz ... | {
"end_col": 62,
"end_line": 22,
"start_col": 2,
"start_line": 22
} |
Prims.Tot | val parse32_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(f': (x: bounded_integer sz -> Tot (y: bool{y == f x})))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata_gen sz f p)) | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(f' : (x: bounded_integer sz) -> Tot (y: bool {y == f x}))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata_gen sz f p))
= [@inline_let]
let _ = parse_vldata_gen_eq_def sz f p in... | val parse32_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(f': (x: bounded_integer sz -> Tot (y: bool{y == f x})))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata_gen sz f p))
let parse32_vldata_gen
... | false | null | false | [@@ inline_let ]let _ = parse_vldata_gen_eq_def sz f p in
parse32_and_then (parse32_filter (parse32_bounded_integer sz) f f')
(parse_vldata_payload sz f p)
()
(parse32_vldata_payload sz f p32) | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.bool",
"Prims.eq2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Combinators.parse32_and_then",
"LowParse.Spec.Combinators.parse_filter_kind",
... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(f': (x: bounded_integer sz -> Tot (y: bool{y == f x})))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_vldata_gen sz f p)) | [] | LowParse.SLow.VLData.parse32_vldata_gen | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: LowParse.Spec.BoundedInt.integer_size ->
f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) ->
f': (x: LowParse.Spec.BoundedInt.bounded_integer sz -> y: Prims.bool{y == f x}) ->
p32: LowParse.SLow.Base.parser32 p
-> LowParse.SLow.Base.parser32 (LowParse.Spec.VLData.parse... | {
"end_col": 37,
"end_line": 40,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | val check_vldata_payload_size32
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967295})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(input: t)
... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let check_vldata_payload_size32
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967295 } ) // necessary to exclude the overflow case; enough to be compatible with serialize32
(max32: U32.t { U32.v max32 == max } )
(#k: parser_kind)
(#t: Type)
(#p: parser k ... | val check_vldata_payload_size32
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967295})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(input: t)
... | false | null | false | let sz:U32.t = s32 input in
[@@ inline_let ]let y:bool = not (sz = u32_max || U32.lt sz min32 || U32.lt max32 sz) in
[@@ inline_let ]let _:squash (y == true <==> parse_bounded_vldata_strong_pred min max s input) =
if sz = u32_max
then
if Seq.length (serialize s input) > U32.v u32_max
then ()
else
... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kin... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val check_vldata_payload_size32
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967295})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(input: t)
... | [] | LowParse.SLow.VLData.check_vldata_payload_size32 | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967295} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
s32: LowParse.SLow.Base.size32 s ->
input: t
-> y:
Prims.bool{y == true <==> LowParse.Spec.VLData.pars... | {
"end_col": 3,
"end_line": 319,
"start_col": 1,
"start_line": 297
} |
Prims.Tot | val parse32_bounded_vldata
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_bounded_vldata min ... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_bounded_vldata
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(max32: U32.t { U32.v max32 == max } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_bounded_vldata min max p))
= parse32_bounde... | val parse32_bounded_vldata
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_bounded_vldata min ... | false | null | false | parse32_bounded_vldata' min min32 max max32 (log256' max) p32 | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kin... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_bounded_vldata
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_bounded_vldata min ... | [] | LowParse.SLow.VLData.parse32_bounded_vldata | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
p32: LowParse.SLow.Base.parser32 p
-> LowParse.SLow.Base.parser32 (LowParse.Spec.VLData.parse_bounded_vldata m... | {
"end_col": 63,
"end_line": 83,
"start_col": 2,
"start_line": 83
} |
Prims.Tot | val serialize32_bounded_vldata_strong
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_bounded_vldata_strong min max s)) | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let serialize32_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_bounded_vldata_strong min ma... | val serialize32_bounded_vldata_strong
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_bounded_vldata_strong min max s))
let seriali... | false | null | false | serialize32_bounded_vldata_strong' min max (log256' max) s32 | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"LowParse.SLow.VLData.serialize32_bounded_v... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val serialize32_bounded_vldata_strong
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_bounded_vldata_strong min max s)) | [] | LowParse.SLow.VLData.serialize32_bounded_vldata_strong | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
s32: LowParse.SLow.Base.partial_serializer32 s
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.VLData.serialize_bounded_vldata_strong min max s
) | {
"end_col": 62,
"end_line": 261,
"start_col": 2,
"start_line": 261
} |
Prims.Tot | val parse32_bounded_vldata_strong
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: parser32 p)
: Tot
(... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_bounded_vldata_strong
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(max32: U32.t { U32.v max32 == max } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: parser32 p)
: Tot (parser32 #_ #(parse_bounded_vlda... | val parse32_bounded_vldata_strong
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: parser32 p)
: Tot
(... | false | null | false | parse32_bounded_vldata_strong' min min32 max max32 (log256' max) s p32 | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kin... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_bounded_vldata_strong
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: parser32 p)
: Tot
(... | [] | LowParse.SLow.VLData.parse32_bounded_vldata_strong | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
s: LowParse.Spec.Base.serializer p ->
p32: LowParse.SLow.Base.parser32 p
-> LowParse.SLow.Base.parser32 (L... | {
"end_col": 72,
"end_line": 181,
"start_col": 2,
"start_line": 181
} |
Prims.Tot | val parse32_bounded_vldata_strong'
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serialize... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_bounded_vldata_strong'
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(max32: U32.t { U32.v max32 == max } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: parser3... | val parse32_bounded_vldata_strong'
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serialize... | false | null | false | make_parser32 (parse_bounded_vldata_strong' min max l s)
(fun input ->
parse32_bounded_vldata_strong_correct min min32 max max32 l s p32 input;
parse32_bounded_vldata_strong_aux min min32 max max32 l s p32 input) | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.BoundedInt.log2... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_bounded_vldata_strong'
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serialize... | [] | LowParse.SLow.VLData.parse32_bounded_vldata_strong' | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p ->
... | {
"end_col": 5,
"end_line": 167,
"start_col": 2,
"start_line": 162
} |
Prims.Tot | val parse32_bounded_vldata_strong_aux
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serial... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_bounded_vldata_strong_aux
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(max32: U32.t { U32.v max32 == max } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: pars... | val parse32_bounded_vldata_strong_aux
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serial... | false | null | false | let res =
parse32_strengthen #(parse_bounded_vldata_strong_kind min max l k)
#t
#(parse_bounded_vldata' min max l #k #t p)
(parse32_bounded_vldata' min min32 max max32 l #k #t #p p32)
(parse_bounded_vldata_strong_pred min max #k #t #p s)
(parse_bounded_vldata_strong_correct min max l #k #t #p s)
... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.BoundedInt.log2... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_bounded_vldata_strong_aux
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serial... | [] | LowParse.SLow.VLData.parse32_bounded_vldata_strong_aux | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p ->
... | {
"end_col": 77,
"end_line": 113,
"start_col": 1,
"start_line": 99
} |
Prims.Tot | val parse32_bounded_vldata'
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_bounded_vldata'
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(max32: U32.t { U32.v max32 == max } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse... | val parse32_bounded_vldata'
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
... | false | null | false | [@@ inline_let ]let _ = parse_bounded_vldata_correct min max l p in
[@@ inline_let ]let sz:integer_size = l in
(fun input ->
parse32_vldata_gen sz
(in_bounds min max)
(fun i -> not (U32.lt i min32 || U32.lt max32 i))
p32
input) | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.BoundedInt.log2... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_bounded_vldata'
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
... | [] | LowParse.SLow.VLData.parse32_bounded_vldata' | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
p32: LowParse.SLow.Base.parser32 p
->... | {
"end_col": 118,
"end_line": 70,
"start_col": 2,
"start_line": 66
} |
Prims.Tot | val serialize32_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_b... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let serialize32_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializ... | val serialize32_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_b... | false | null | false | fun (input: parse_bounded_vldata_strong_t min max s) ->
serialize32_bounded_vldata_strong_correct min max l s32 input;
(serialize32_bounded_vldata_strong_aux min max l s32 input
<:
(res: bytes32{serializer32_correct (serialize_bounded_vldata_strong' min max l s) input res})) | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Ba... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val serialize32_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (serializer32 (serialize_b... | [] | LowParse.SLow.VLData.serialize32_bounded_vldata_strong' | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s32: LowParse.SLow.Base.partial_serializer32 s
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.VLData.serialize_bounded_vldata_strong' min
ma... | {
"end_col": 162,
"end_line": 249,
"start_col": 2,
"start_line": 247
} |
Prims.Tot | val serialize32_bounded_vldata
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s {serialize_bounded_vldata_precond min max k})
: Tot (serializer32 (serialize_bounded... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let serialize32_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s { serialize_bounded_vldata_precond min max k } )
: Tot (serializer... | val serialize32_bounded_vldata
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s {serialize_bounded_vldata_precond min max k})
: Tot (serializer32 (serialize_bounded... | false | null | false | fun (input: t) ->
[@@ inline_let ]let _:unit =
let Some (_, consumed) = parse p (serialize s input) in
()
in
serialize32_bounded_vldata_strong_correct min max (log256' max) s32 input;
(serialize32_bounded_vldata_strong_aux min max (log256' max) s32 input
<:
(res: bytes32{serializer32_correct (se... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"LowParse.Spec.VLData.serialize_bounded_vld... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val serialize32_bounded_vldata
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s {serialize_bounded_vldata_precond min max k})
: Tot (serializer32 (serialize_bounded... | [] | LowParse.SLow.VLData.serialize32_bounded_vldata | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
s32:
LowParse.SLow.Base.partial_serializer32 s
{LowParse.Spec.VLData.serialize_bounded_vldata_precond min max k}
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.VLData.serialize_bounded_vldata min max s) | {
"end_col": 164,
"end_line": 280,
"start_col": 2,
"start_line": 273
} |
Prims.Tot | val size32_bounded_vldata_strong
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t{U32.v sz32 == log256' max})
: Tot (size32 (serialize_bounded_vldata_strong m... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let size32_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4, otherwise add overflows
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t { U32.v sz32 == log256' max } )
: Tot ... | val size32_bounded_vldata_strong
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t{U32.v sz32 == log256' max})
: Tot (size32 (serialize_bounded_vldata_strong m... | false | null | false | size32_bounded_vldata_strong' min max (log256' max) s32 sz32 | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val size32_bounded_vldata_strong
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t{U32.v sz32 == log256' max})
: Tot (size32 (serialize_bounded_vldata_strong m... | [] | LowParse.SLow.VLData.size32_bounded_vldata_strong | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
s32: LowParse.SLow.Base.size32 s ->
sz32: FStar.UInt32.t{FStar.UInt32.v sz32 == LowParse.Spec.BoundedInt.log256' max}
-> LowParse.SLow.Base.size32 (LowParse.Spec.VLData.serialize_bounded_vldata_strong min max s) | {
"end_col": 62,
"end_line": 354,
"start_col": 2,
"start_line": 354
} |
Prims.Tot | val serialize32_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (parse_bounded_vldata_s... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let serialize32_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (parse... | val serialize32_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (parse_bounded_vldata_s... | false | null | false | [@@ inline_let ]let sz:integer_size = l in
[@@ inline_let ]let ser:serializer32 (serialize_bounded_integer sz) =
serialize32_bounded_integer sz
in
(fun (input: parse_bounded_vldata_strong_t min max s) ->
let pl = s32 input in
let len = B32.len pl in
assert (min <= U32.v len /\ U32.v len <= max);
let s... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Ba... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val serialize32_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
: Tot (parse_bounded_vldata_s... | [] | LowParse.SLow.VLData.serialize32_bounded_vldata_strong_aux | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
_: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s
-> LowParse.SLow.Base.bytes32 | {
"end_col": 8,
"end_line": 206,
"start_col": 2,
"start_line": 194
} |
FStar.Pervasives.Lemma | val parse32_bounded_vldata_strong_correct
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: se... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let parse32_bounded_vldata_strong_correct
(min: nat)
(min32: U32.t { U32.v min32 == min } )
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(max32: U32.t { U32.v max32 == max } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(p32: ... | val parse32_bounded_vldata_strong_correct
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: se... | false | null | true | let res =
parse32_strengthen #(parse_bounded_vldata_strong_kind min max l k)
#t
#(parse_bounded_vldata' min max l #k #t p)
(parse32_bounded_vldata' min min32 max max32 l #k #t #p p32)
(parse_bounded_vldata_strong_pred min max #k #t #p s)
(parse_bounded_vldata_strong_correct min max l #k #t #p s)
... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"lemma"
] | [
"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",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.BoundedInt.log2... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parse32_bounded_vldata_strong_correct
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(max32: U32.t{U32.v max32 == max})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: se... | [] | LowParse.SLow.VLData.parse32_bounded_vldata_strong_correct | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p ->
... | {
"end_col": 82,
"end_line": 147,
"start_col": 1,
"start_line": 132
} |
Prims.Tot | val size32_bounded_vldata
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s {serialize_bounded_vldata_precond min max k})
(sz32: U32.t{U32.v sz32 == log256' max})
: Tot (siz... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let size32_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s { serialize_bounded_vldata_precond min max k } )
(sz32: U32.t { U32.v sz32 == log25... | val size32_bounded_vldata
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s {serialize_bounded_vldata_precond min max k})
(sz32: U32.t{U32.v sz32 == log256' max})
: Tot (siz... | false | null | false | fun (input: t) ->
[@@ inline_let ]let _:unit =
let Some (_, consumed) = parse p (serialize s input) in
()
in
(size32_bounded_vldata_strong min max s32 sz32 input
<:
(res: U32.t{size32_postcond (serialize_bounded_vldata min max s) input res})) | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"LowParse.Spec.VLData.serialize_bounded_vldata_precond",
... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val size32_bounded_vldata
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s {serialize_bounded_vldata_precond min max k})
(sz32: U32.t{U32.v sz32 == log256' max})
: Tot (siz... | [] | LowParse.SLow.VLData.size32_bounded_vldata | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
s32:
LowParse.SLow.Base.size32 s {LowParse.Spec.VLData.serialize_bounded_vldata_precond min max k} ->
sz32: FStar.UInt32.t{FStar.UInt32.v sz32 == LowParse.Spec.BoundedInt.log256' max}
-> LowParse.SLow.Base.size32 (Lo... | {
"end_col": 139,
"end_line": 373,
"start_col": 2,
"start_line": 367
} |
FStar.Pervasives.Lemma | val serialize32_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
(input: parse_bounded_v... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let serialize32_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
(input... | val serialize32_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
(input: parse_bounded_v... | false | null | true | let sz:integer_size = l in
let ser:serializer32 (serialize_bounded_integer sz) = serialize32_bounded_integer sz in
let pl = s32 input in
assert (B32.reveal pl == s input);
let len = B32.len pl in
let nlen = U32.v len in
assert (min <= nlen /\ nlen <= max);
let slen = ser (len <: bounded_integer sz) in
assert (B32.revea... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Ba... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val serialize32_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: partial_serializer32 s)
(input: parse_bounded_v... | [] | LowParse.SLow.VLData.serialize32_bounded_vldata_strong_correct | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
input: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s
-> FStar.Pervasives.Lemma
(... | {
"end_col": 88,
"end_line": 234,
"start_col": 1,
"start_line": 220
} |
Prims.Tot | val size32_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t{U32.v sz32 == l})
: Tot (size32 ... | [
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Lo... | false | let size32_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967292 } ) // NOTE here: max must be less than 2^32 - 4, otherwise add overflows
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: ... | val size32_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t{U32.v sz32 == l})
: Tot (size32 ... | false | null | false | (fun (input: parse_bounded_vldata_strong_t min max s) ->
let len = s32 input in
[@@ inline_let ]let _ = assert_norm (U32.v u32_max == 4294967295) in
[@@ inline_let ]let _ = assert (min <= U32.v len /\ U32.v len <= max) in
[@@ inline_let ]let res:U32.t = U32.add sz32 len in
(res <: (res: U32.t{size32... | {
"checked_file": "LowParse.SLow.VLData.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.VLData.fsti.checked",
"LowParse.SLow.FLData.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.check... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Ba... | [] | module LowParse.SLow.VLData
include LowParse.Spec.VLData
include LowParse.SLow.FLData
include LowParse.SLow.BoundedInt // for bounded_integer
module Seq = FStar.Seq
module U32 = FStar.UInt32
module B32 = LowParse.Bytes32
(* Parsers and serializers for the payload *)
inline_for_extraction
let parse32_vldata_payload
... | false | false | LowParse.SLow.VLData.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val size32_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967292})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(sz32: U32.t{U32.v sz32 == l})
: Tot (size32 ... | [] | LowParse.SLow.VLData.size32_bounded_vldata_strong' | {
"file_name": "src/lowparse/LowParse.SLow.VLData.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967292} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s32: LowParse.SLow.Base.size32 s ->
sz32: FStar.UInt32.t{FStar.UInt32.v sz32 == l}
-> LowParse.SLow.Base.size32 (LowParse.Spec.VLData.serialize_bound... | {
"end_col": 105,
"end_line": 341,
"start_col": 2,
"start_line": 333
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let prime (a:algorithm) =
match a with
| DH_Curve25519 -> Spec.Curve25519.prime
| DH_P256 -> Spec.P256.prime | let prime (a: algorithm) = | false | null | false | match a with
| DH_Curve25519 -> Spec.Curve25519.prime
| DH_P256 -> Spec.P256.prime | {
"checked_file": "Spec.Agile.DH.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.che... | [
"total"
] | [
"Spec.Agile.DH.algorithm",
"Spec.Curve25519.prime",
"Spec.P256.PointOps.prime",
"Prims.pos"
] | [] | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction
let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32
inline_for_extraction
let size_publi... | false | true | Spec.Agile.DH.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val prime : a: Spec.Agile.DH.algorithm -> Prims.pos | [] | Spec.Agile.DH.prime | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.DH.algorithm -> Prims.pos | {
"end_col": 30,
"end_line": 31,
"start_col": 2,
"start_line": 29
} | |
Prims.Tot | val secret_to_public: a:algorithm -> scalar a -> Tot (option (serialized_point a)) | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let secret_to_public a kpriv =
match a with
| DH_Curve25519 -> Some (Spec.Curve25519.secret_to_public kpriv)
| DH_P256 -> Spec.P256.secret_to_public kpriv | val secret_to_public: a:algorithm -> scalar a -> Tot (option (serialized_point a))
let secret_to_public a kpriv = | false | null | false | match a with
| DH_Curve25519 -> Some (Spec.Curve25519.secret_to_public kpriv)
| DH_P256 -> Spec.P256.secret_to_public kpriv | {
"checked_file": "Spec.Agile.DH.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.che... | [
"total"
] | [
"Spec.Agile.DH.algorithm",
"Spec.Agile.DH.scalar",
"FStar.Pervasives.Native.Some",
"Spec.Agile.DH.serialized_point",
"Spec.Curve25519.secret_to_public",
"Spec.P256.secret_to_public",
"FStar.Pervasives.Native.option"
] | [] | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction
let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32
inline_for_extraction
let size_publi... | false | false | Spec.Agile.DH.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val secret_to_public: a:algorithm -> scalar a -> Tot (option (serialized_point a)) | [] | Spec.Agile.DH.secret_to_public | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.DH.algorithm -> kpriv: Spec.Agile.DH.scalar a
-> FStar.Pervasives.Native.option (Spec.Agile.DH.serialized_point a) | {
"end_col": 47,
"end_line": 62,
"start_col": 2,
"start_line": 60
} |
Prims.Tot | val clamp: alg:algorithm{alg = DH_Curve25519} -> scalar alg -> Tot (scalar alg) | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let clamp a k =
match a with
| DH.DH_Curve25519 -> Spec.Curve25519.decodeScalar k | val clamp: alg:algorithm{alg = DH_Curve25519} -> scalar alg -> Tot (scalar alg)
let clamp a k = | false | null | false | match a with | DH.DH_Curve25519 -> Spec.Curve25519.decodeScalar k | {
"checked_file": "Spec.Agile.DH.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.che... | [
"total"
] | [
"Spec.Agile.DH.algorithm",
"Prims.b2t",
"Prims.op_Equality",
"Spec.Agile.DH.DH_Curve25519",
"Spec.Agile.DH.scalar",
"Spec.Curve25519.decodeScalar"
] | [] | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction
let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32
inline_for_extraction
let size_publi... | false | false | Spec.Agile.DH.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val clamp: alg:algorithm{alg = DH_Curve25519} -> scalar alg -> Tot (scalar alg) | [] | Spec.Agile.DH.clamp | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | alg: Spec.Agile.DH.algorithm{alg = Spec.Agile.DH.DH_Curve25519} -> k: Spec.Agile.DH.scalar alg
-> Spec.Agile.DH.scalar alg | {
"end_col": 54,
"end_line": 44,
"start_col": 2,
"start_line": 43
} |
Prims.Tot | val size_key (a: algorithm) : Tot size_nat | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32 | val size_key (a: algorithm) : Tot size_nat
let size_key (a: algorithm) : Tot size_nat = | false | null | false | match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32 | {
"checked_file": "Spec.Agile.DH.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.che... | [
"total"
] | [
"Spec.Agile.DH.algorithm",
"Lib.IntTypes.size_nat"
] | [] | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction | false | true | Spec.Agile.DH.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val size_key (a: algorithm) : Tot size_nat | [] | Spec.Agile.DH.size_key | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.DH.algorithm -> Lib.IntTypes.size_nat | {
"end_col": 17,
"end_line": 19,
"start_col": 2,
"start_line": 17
} |
Prims.Tot | val size_public (a: algorithm) : Tot size_nat | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let size_public (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 64 | val size_public (a: algorithm) : Tot size_nat
let size_public (a: algorithm) : Tot size_nat = | false | null | false | match a with
| DH_Curve25519 -> 32
| DH_P256 -> 64 | {
"checked_file": "Spec.Agile.DH.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.che... | [
"total"
] | [
"Spec.Agile.DH.algorithm",
"Lib.IntTypes.size_nat"
] | [] | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction
let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32
inline_for_extraction | false | true | Spec.Agile.DH.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val size_public (a: algorithm) : Tot size_nat | [] | Spec.Agile.DH.size_public | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.DH.algorithm -> Lib.IntTypes.size_nat | {
"end_col": 17,
"end_line": 25,
"start_col": 2,
"start_line": 23
} |
Prims.Tot | val dh: a:algorithm -> s:scalar a -> p:serialized_point a -> Tot (option (serialized_point a)) | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let dh a s p =
match a with
| DH_Curve25519 ->
let output = Spec.Curve25519.scalarmult s p in
let is_valid = not (lbytes_eq (create (size_public a) (u8 0)) output) in
if is_valid then Some output else None
| DH_P256 ->
Spec.P256.ecdh p s | val dh: a:algorithm -> s:scalar a -> p:serialized_point a -> Tot (option (serialized_point a))
let dh a s p = | false | null | false | match a with
| DH_Curve25519 ->
let output = Spec.Curve25519.scalarmult s p in
let is_valid = not (lbytes_eq (create (size_public a) (u8 0)) output) in
if is_valid then Some output else None
| DH_P256 -> Spec.P256.ecdh p s | {
"checked_file": "Spec.Agile.DH.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.che... | [
"total"
] | [
"Spec.Agile.DH.algorithm",
"Spec.Agile.DH.scalar",
"Spec.Agile.DH.serialized_point",
"FStar.Pervasives.Native.Some",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_Negation",
"Lib.ByteSequence.lbytes_eq",
"Spec.Agile.DH.size_public",
"Lib.Sequence.creat... | [] | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction
let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32
inline_for_extraction
let size_publi... | false | false | Spec.Agile.DH.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val dh: a:algorithm -> s:scalar a -> p:serialized_point a -> Tot (option (serialized_point a)) | [] | Spec.Agile.DH.dh | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Agile.DH.algorithm -> s: Spec.Agile.DH.scalar a -> p: Spec.Agile.DH.serialized_point a
-> FStar.Pervasives.Native.option (Spec.Agile.DH.serialized_point a) | {
"end_col": 22,
"end_line": 56,
"start_col": 2,
"start_line": 50
} |
FStar.Pervasives.Lemma | val lemma_reverse_reverse_bytes_nat32_seq (s:seq nat32) :
Lemma (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s) == s)
[SMTPat (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s))] | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_reverse_reverse_bytes_nat32_seq (s:seq nat32) :
Lemma (ensures reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s) == s)
=
reveal_reverse_bytes_nat32_seq s;
reveal_reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s);
assert (equal (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s)) s) | val lemma_reverse_reverse_bytes_nat32_seq (s:seq nat32) :
Lemma (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s) == s)
[SMTPat (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s))]
let lemma_reverse_reverse_bytes_nat32_seq (s: seq nat32)
: Lemma (ensures reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s) ... | false | null | true | reveal_reverse_bytes_nat32_seq s;
reveal_reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s);
assert (equal (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s)) s) | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Types_s.nat32",
"Vale.Def.Types_s.reverse_bytes_nat32_seq",
"Prims.unit",
"Vale.Def.Types_s.reveal_reverse_bytes_nat32_seq",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Per... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reverse_reverse_bytes_nat32_seq (s:seq nat32) :
Lemma (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s) == s)
[SMTPat (reverse_bytes_nat32_seq (reverse_bytes_nat32_seq s))] | [] | Vale.Arch.Types.lemma_reverse_reverse_bytes_nat32_seq | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.reverse_bytes_nat32_seq (Vale.Def.Types_s.reverse_bytes_nat32_seq s) == s)
[
SMTPat (Vale.Def.Types_s.reverse_bytes_nat32_seq (Vale.Def.Types_s.reverse_bytes_nat32_seq s
))
... | {
"end_col": 72,
"end_line": 111,
"start_col": 2,
"start_line": 109
} |
FStar.Pervasives.Lemma | val lemma_reverse_reverse_bytes_nat32 (n:nat32) :
Lemma (reverse_bytes_nat32 (reverse_bytes_nat32 n) == n)
[SMTPat (reverse_bytes_nat32 (reverse_bytes_nat32 n))] | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_reverse_reverse_bytes_nat32 (n:nat32) :
Lemma (reverse_bytes_nat32 (reverse_bytes_nat32 n) == n)
=
reverse_bytes_nat32_reveal ();
let r = reverse_seq (nat32_to_be_bytes n) in
be_bytes_to_nat32_to_be_bytes r;
() | val lemma_reverse_reverse_bytes_nat32 (n:nat32) :
Lemma (reverse_bytes_nat32 (reverse_bytes_nat32 n) == n)
[SMTPat (reverse_bytes_nat32 (reverse_bytes_nat32 n))]
let lemma_reverse_reverse_bytes_nat32 (n: nat32)
: Lemma (reverse_bytes_nat32 (reverse_bytes_nat32 n) == n) = | false | null | true | reverse_bytes_nat32_reveal ();
let r = reverse_seq (nat32_to_be_bytes n) in
be_bytes_to_nat32_to_be_bytes r;
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Vale.Def.Types_s.be_bytes_to_nat32_to_be_bytes",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Vale.Lib.Seqs_s.reverse_seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.nat32_to_be_bytes",
"Vale.Def.Types_s.reverse_bytes_nat32_reveal",
"Prims.l_True",
"P... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reverse_reverse_bytes_nat32 (n:nat32) :
Lemma (reverse_bytes_nat32 (reverse_bytes_nat32 n) == n)
[SMTPat (reverse_bytes_nat32 (reverse_bytes_nat32 n))] | [] | Vale.Arch.Types.lemma_reverse_reverse_bytes_nat32 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Types_s.reverse_bytes_nat32 n) == n)
[SMTPat (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Types_s.reverse_bytes_nat32 n))] | {
"end_col": 4,
"end_line": 74,
"start_col": 2,
"start_line": 71
} |
FStar.Pervasives.Lemma | val lemma_BitwiseXorCancel (n:nat32) : Lemma (n *^ n == 0) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_BitwiseXorCancel n =
lemma_ixor_nth_all 32;
lemma_zero_nth 32;
lemma_equal_nth 32 (n *^ n) 0 | val lemma_BitwiseXorCancel (n:nat32) : Lemma (n *^ n == 0)
let lemma_BitwiseXorCancel n = | false | null | true | lemma_ixor_nth_all 32;
lemma_zero_nth 32;
lemma_equal_nth 32 (n *^ n) 0 | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.nat32",
"Vale.Arch.TypesNative.lemma_equal_nth",
"Vale.Arch.Types.op_Star_Hat",
"Prims.unit",
"Vale.Arch.TypesNative.lemma_zero_nth",
"Vale.Arch.TypesNative.lemma_ixor_nth_all"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_BitwiseXorCancel (n:nat32) : Lemma (n *^ n == 0) | [] | Vale.Arch.Types.lemma_BitwiseXorCancel | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Vale.Def.Words_s.nat32 -> FStar.Pervasives.Lemma (ensures n *^ n == 0) | {
"end_col": 31,
"end_line": 28,
"start_col": 2,
"start_line": 26
} |
FStar.Pervasives.Lemma | val be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b')
=
be_quad32_to_bytes_injective() | val be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b')
let be_quad32_to_bytes_injective_specific (b b': quad32)
: Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') = | false | null | true | be_quad32_to_bytes_injective () | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Vale.Arch.Types.be_quad32_to_bytes_injective",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Words_s.nat8",
"Vale.Arch.Types.be_quad32_to_bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | [] | Vale.Arch.Types.be_quad32_to_bytes_injective_specific | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Vale.Def.Types_s.quad32 -> b': Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.be_quad32_to_bytes b == Vale.Arch.Types.be_quad32_to_bytes b' ==> b == b') | {
"end_col": 32,
"end_line": 507,
"start_col": 2,
"start_line": 507
} |
FStar.Pervasives.Lemma | val be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q))) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q)))
=
reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
four_to_seq_BE_is_seq_four_to_seq_BE q;
() | val be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q)))
let be_seq_quad32_to_bytes_of_singleton (q: quad32)
: Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q))) = | false | null | true | reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
four_to_seq_BE_is_seq_four_to_seq_BE q;
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.four_to_seq_BE_is_seq_four_to_seq_BE",
"FStar.Pervasives.reveal_opaque",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Words_s.nat8",
"Vale.Arch.Types.be_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.seq",
... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q))) | [] | Vale.Arch.Types.be_seq_quad32_to_bytes_of_singleton | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.be_quad32_to_bytes q ==
Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE (FStar.Seq.Base.create
1
q))) | {
"end_col": 4,
"end_line": 453,
"start_col": 2,
"start_line": 451
} |
FStar.Pervasives.Lemma | val lemma_BitwiseXorCancel64 (n:nat64) : Lemma (ixor n n == 0) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_BitwiseXorCancel64 (n:nat64) =
lemma_ixor_nth_all 64;
lemma_zero_nth 64;
lemma_equal_nth 64 (ixor n n) 0 | val lemma_BitwiseXorCancel64 (n:nat64) : Lemma (ixor n n == 0)
let lemma_BitwiseXorCancel64 (n: nat64) = | false | null | true | lemma_ixor_nth_all 64;
lemma_zero_nth 64;
lemma_equal_nth 64 (ixor n n) 0 | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.nat64",
"Vale.Arch.TypesNative.lemma_equal_nth",
"Vale.Def.Types_s.ixor",
"Vale.Def.Words_s.pow2_64",
"Prims.unit",
"Vale.Arch.TypesNative.lemma_zero_nth",
"Vale.Arch.TypesNative.lemma_ixor_nth_all"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_BitwiseXorCancel64 (n:nat64) : Lemma (ixor n n == 0) | [] | Vale.Arch.Types.lemma_BitwiseXorCancel64 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Vale.Def.Words_s.nat64 -> FStar.Pervasives.Lemma (ensures Vale.Def.Types_s.ixor n n == 0) | {
"end_col": 33,
"end_line": 33,
"start_col": 2,
"start_line": 31
} |
FStar.Pervasives.Lemma | val lemma_reverse_bytes_quad32 (q:quad32) :
Lemma (reverse_bytes_quad32 (reverse_bytes_quad32 q) == q)
[SMTPat (reverse_bytes_quad32 (reverse_bytes_quad32 q))] | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_reverse_bytes_quad32 (q:quad32) =
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
reveal_reverse_bytes_quad32 q;
reveal_reverse_bytes_quad32 (reverse_bytes_quad32 q);
() | val lemma_reverse_bytes_quad32 (q:quad32) :
Lemma (reverse_bytes_quad32 (reverse_bytes_quad32 q) == q)
[SMTPat (reverse_bytes_quad32 (reverse_bytes_quad32 q))]
let lemma_reverse_bytes_quad32 (q: quad32) = | false | null | true | quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
reveal_reverse_bytes_quad32 q;
reveal_reverse_bytes_quad32 (reverse_bytes_quad32 q);
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Types_s.reveal_reverse_bytes_quad32",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.Def.Types_s.reverse_bytes_nat32_reveal",
"Vale.Def.Types_s.quad32_xor_reveal"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reverse_bytes_quad32 (q:quad32) :
Lemma (reverse_bytes_quad32 (reverse_bytes_quad32 q) == q)
[SMTPat (reverse_bytes_quad32 (reverse_bytes_quad32 q))] | [] | Vale.Arch.Types.lemma_reverse_bytes_quad32 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.reverse_bytes_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 q) == q)
[SMTPat (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 q))] | {
"end_col": 4,
"end_line": 82,
"start_col": 2,
"start_line": 78
} |
FStar.Pervasives.Lemma | val lemma_hi64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern hi64 q0; hi64 q1}
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_hi64_properties (_:unit) :
Lemma (forall (q0 q1:quad32) . (q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1))
=
hi64_reveal ();
let helper (q0 q1:quad32) : Lemma ((q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) =
let Mktwo n1 n2 = two_select (four_to_two_two q0) 1 i... | val lemma_hi64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern hi64 q0; hi64 q1}
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1))
let lemma_hi64_properties (_: unit)
: Lemma
(forall (q0: quad32) (q1: quad32).
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi6... | false | null | true | hi64_reveal ();
let helper (q0 q1: quad32)
: Lemma ((q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) =
let Mktwo n1 n2 = two_select (four_to_two_two q0) 1 in
nat_to_two_to_nat n1 n2;
let Mktwo n1 n2 = two_select (four_to_two_two q1) 1 in
nat_to_two_to_nat n1 n2;
()
in
FStar.Classical.fora... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_iff",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.nat64",
"Vale.Arch.Types.hi64",
"Prims.l... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_hi64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern hi64 q0; hi64 q1}
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) | [] | Vale.Arch.Types.lemma_hi64_properties | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (q0: Vale.Def.Types_s.quad32) (q1: Vale.Def.Types_s.quad32).
{:pattern Vale.Arch.Types.hi64 q0; Vale.Arch.Types.hi64 q1}
Mkfour?.hi2 q0 == Mkfour?.hi2 q1 /\ Mkfour?.hi3 q0 == Mkfour?.hi3 q1 <==>
Vale.Arch.Types.hi64 q0 == Vale.A... | {
"end_col": 4,
"end_line": 193,
"start_col": 2,
"start_line": 184
} |
FStar.Pervasives.Lemma | val lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))] | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))]
=
seq_map_inverses reverse_bytes_quad32 reverse_bytes_quad32 s | val lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))]
let lemma_reverse_reverse_bytes_quad32_seq (s: seq quad32)
: Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s... | false | null | true | seq_map_inverses reverse_bytes_quad32 reverse_bytes_quad32 s | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Arch.Types.reverse_bytes_quad32_seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))] | [] | Vale.Arch.Types.lemma_reverse_reverse_bytes_quad32_seq | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.reverse_bytes_quad32_seq (Vale.Arch.Types.reverse_bytes_quad32_seq s) == s)
[
SMTPat (Vale.Arch.Types.reverse_bytes_quad32_seq (Vale.Arch.Types.reverse_bytes_quad32_seq s
))
... | {
"end_col": 62,
"end_line": 602,
"start_col": 2,
"start_line": 602
} |
FStar.Pervasives.Lemma | val le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q))
=
le_seq_quad32_to_bytes_reveal ();
reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
four_to_seq_LE_is_seq_four_to_seq_LE q;
() | val le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q))
let le_seq_quad32_to_bytes_of_singleton (q: quad32)
: Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)) = | false | null | true | le_seq_quad32_to_bytes_reveal ();
reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
four_to_seq_LE_is_seq_four_to_seq_LE q;
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.four_to_seq_LE_is_seq_four_to_seq_LE",
"Vale.Def.Types_s.nat32",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.l_True",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.le... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)) | [] | Vale.Arch.Types.le_seq_quad32_to_bytes_of_singleton | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_quad32_to_bytes q ==
Vale.Def.Types_s.le_seq_quad32_to_bytes (FStar.Seq.Base.create 1 q)) | {
"end_col": 4,
"end_line": 446,
"start_col": 2,
"start_line": 443
} |
FStar.Pervasives.Lemma | val lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))] | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))]
=
let s' = reverse_bytes_nat32_quad32 s in
let s''= reverse_bytes_nat32_quad32 s' in
assert (s''.lo0 == revers... | val lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))]
let lemma_reverse_reverse_bytes_nat32_quad32 (s: quad32)
: Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_... | false | null | true | let s' = reverse_bytes_nat32_quad32 s in
let s'' = reverse_bytes_nat32_quad32 s' in
assert (s''.lo0 == reverse_bytes_nat32 (reverse_bytes_nat32 s.lo0));
assert (s''.lo1 == reverse_bytes_nat32 (reverse_bytes_nat32 s.lo1));
assert (s''.hi2 == reverse_bytes_nat32 (reverse_bytes_nat32 s.hi2));
assert (s''.hi3 == reverse_by... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.reverse_bytes_nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__pro... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))] | [] | Vale.Arch.Types.lemma_reverse_reverse_bytes_nat32_quad32 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.reverse_bytes_nat32_quad32 (Vale.Arch.Types.reverse_bytes_nat32_quad32 s) ==
s)
[
SMTPat (Vale.Arch.Types.reverse_bytes_nat32_quad32 (Vale.Arch.Types.reverse_bytes_nat32_quad32
s))
... | {
"end_col": 4,
"end_line": 590,
"start_col": 3,
"start_line": 583
} |
FStar.Pervasives.Lemma | val lemma_BitwiseXorWithZero (n:nat32) : Lemma (n *^ 0 == n) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_BitwiseXorWithZero n =
lemma_ixor_nth_all 32;
lemma_zero_nth 32;
lemma_equal_nth 32 (n *^ 0) n | val lemma_BitwiseXorWithZero (n:nat32) : Lemma (n *^ 0 == n)
let lemma_BitwiseXorWithZero n = | false | null | true | lemma_ixor_nth_all 32;
lemma_zero_nth 32;
lemma_equal_nth 32 (n *^ 0) n | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.nat32",
"Vale.Arch.TypesNative.lemma_equal_nth",
"Vale.Arch.Types.op_Star_Hat",
"Prims.unit",
"Vale.Arch.TypesNative.lemma_zero_nth",
"Vale.Arch.TypesNative.lemma_ixor_nth_all"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_BitwiseXorWithZero (n:nat32) : Lemma (n *^ 0 == n) | [] | Vale.Arch.Types.lemma_BitwiseXorWithZero | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Vale.Def.Words_s.nat32 -> FStar.Pervasives.Lemma (ensures n *^ 0 == n) | {
"end_col": 31,
"end_line": 23,
"start_col": 2,
"start_line": 21
} |
FStar.Pervasives.Lemma | val lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
[SMTPat (insert_nat64 q n)] | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
=
insert_nat64_reveal ();
() | val lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
[SMTPat (insert_nat64 q n)]
let lemma_insert_nat64_p... | false | null | true | insert_nat64_reveal ();
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Words_s.nat64",
"Prims.unit",
"Vale.Def.Types_s.insert_nat64_reveal",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
[SMTPat (insert_nat64 q n)] | [] | Vale.Arch.Types.lemma_insert_nat64_properties | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32 -> n: Vale.Def.Words_s.nat64
-> FStar.Pervasives.Lemma
(ensures
(let q' = Vale.Def.Types_s.insert_nat64 q n 0 in
Mkfour?.hi2 q' == Mkfour?.hi2 q /\ Mkfour?.hi3 q' == Mkfour?.hi3 q) /\
(let q' = Vale.Def.Types_s.insert_nat64 q n 1 in
Mkfour?.lo0 q' =... | {
"end_col": 4,
"end_line": 155,
"start_col": 2,
"start_line": 154
} |
FStar.Pervasives.Lemma | val lemma_reverse_bytes_quad32_zero (_:unit) : Lemma
(let z = Mkfour 0 0 0 0 in
reverse_bytes_quad32 z == z) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_reverse_bytes_quad32_zero (_:unit) : Lemma
(let z = Mkfour 0 0 0 0 in
reverse_bytes_quad32 z == z)
=
let z = Mkfour 0 0 0 0 in
calc (==) {
reverse_bytes_quad32 z;
== { reveal_reverse_bytes_quad32 z }
four_reverse (four_map reverse_bytes_nat32 z);
== { lemma_reverse_bytes_nat32() }
... | val lemma_reverse_bytes_quad32_zero (_:unit) : Lemma
(let z = Mkfour 0 0 0 0 in
reverse_bytes_quad32 z == z)
let lemma_reverse_bytes_quad32_zero (_: unit)
: Lemma
(let z = Mkfour 0 0 0 0 in
reverse_bytes_quad32 z == z) = | false | null | true | let z = Mkfour 0 0 0 0 in
calc ( == ) {
reverse_bytes_quad32 z;
( == ) { reveal_reverse_bytes_quad32 z }
four_reverse (four_map reverse_bytes_nat32 z);
( == ) { lemma_reverse_bytes_nat32 () }
z;
};
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Calc.calc_finish",
"Vale.Def.Types_s.quad32",
"Prims.eq2",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Vale.Def.Words.Four_s.four_reverse",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words.Four_s.four_map... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reverse_bytes_quad32_zero (_:unit) : Lemma
(let z = Mkfour 0 0 0 0 in
reverse_bytes_quad32 z == z) | [] | Vale.Arch.Types.lemma_reverse_bytes_quad32_zero | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
(let z = Vale.Def.Words_s.Mkfour 0 0 0 0 in
Vale.Def.Types_s.reverse_bytes_quad32 z == z)) | {
"end_col": 4,
"end_line": 104,
"start_col": 3,
"start_line": 95
} |
FStar.Pervasives.Lemma | val le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b')
=
le_quad32_to_bytes_injective() | val le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b')
let le_quad32_to_bytes_injective_specific (b b': quad32)
: Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') = | false | null | true | le_quad32_to_bytes_injective () | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Vale.Arch.Types.le_quad32_to_bytes_injective",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | [] | Vale.Arch.Types.le_quad32_to_bytes_injective_specific | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Vale.Def.Types_s.quad32 -> b': Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_quad32_to_bytes b == Vale.Def.Types_s.le_quad32_to_bytes b' ==> b == b') | {
"end_col": 32,
"end_line": 502,
"start_col": 2,
"start_line": 502
} |
FStar.Pervasives.Lemma | val seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s)
=
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (create 1 (seq_to_four_BE s)) (seq_to_seq_four_BE s));
() | val seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s)
let seq_to_four_BE_is_seq_to_seq_four_BE (#a: Type) (s: seq4 a)
: Lemma (create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s) = | false | null | true | reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (create 1 (seq_to_four_BE s)) (seq_to_seq_four_BE s));
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words.Seq_s.seq4",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words_s.four",
"FStar.Seq.Base.create",
"Vale.Def.Words.Seq_s.seq_to_four_BE",
"Vale.Def.Words.Seq_s.seq_to_seq_four_BE",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.in... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s) | [] | Vale.Arch.Types.seq_to_four_BE_is_seq_to_seq_four_BE | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.Def.Words.Seq_s.seq4 a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.create 1 (Vale.Def.Words.Seq_s.seq_to_four_BE s) ==
Vale.Def.Words.Seq_s.seq_to_seq_four_BE s) | {
"end_col": 4,
"end_line": 529,
"start_col": 2,
"start_line": 527
} |
FStar.Pervasives.Lemma | val lemma_quad32_xor (_:unit) : Lemma (forall q . {:pattern quad32_xor q q} quad32_xor q q == Mkfour 0 0 0 0) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_quad32_xor () =
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
xor_lemmas() | val lemma_quad32_xor (_:unit) : Lemma (forall q . {:pattern quad32_xor q q} quad32_xor q q == Mkfour 0 0 0 0)
let lemma_quad32_xor () = | false | null | true | quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
xor_lemmas () | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"Vale.Arch.Types.xor_lemmas",
"Vale.Def.Types_s.reverse_bytes_nat32_reveal",
"Vale.Def.Types_s.quad32_xor_reveal"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_quad32_xor (_:unit) : Lemma (forall q . {:pattern quad32_xor q q} quad32_xor q q == Mkfour 0 0 0 0) | [] | Vale.Arch.Types.lemma_quad32_xor | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (q: Vale.Def.Types_s.quad32). {:pattern Vale.Def.Types_s.quad32_xor q q}
Vale.Def.Types_s.quad32_xor q q == Vale.Def.Words_s.Mkfour 0 0 0 0) | {
"end_col": 14,
"end_line": 51,
"start_col": 2,
"start_line": 49
} |
FStar.Pervasives.Lemma | val slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n))) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n)))
=
slice_commutes_be_seq_quad32_to_bytes s 0 n | val slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n)))
let slice_commutes_be_seq_quad32_to_bytes0 (s: seq quad32) (n: nat{n <= length s})
: L... | false | null | true | slice_commutes_be_seq_quad32_to_bytes s 0 n | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Vale.Arch.Types.slice_commutes_be_seq_quad32_to_bytes",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Words_s.nat8",
"FStar.Seq.Base.slice",... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n))) | [] | Vale.Arch.Types.slice_commutes_be_seq_quad32_to_bytes0 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> n: Prims.nat{n <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE
s))
0
(n * 16) ==
Vale.Def.Words.S... | {
"end_col": 45,
"end_line": 674,
"start_col": 2,
"start_line": 674
} |
FStar.Pervasives.Lemma | val le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s)
(* This expands into showing:
le_bytes_to_seq_quad32 (le_quad32_to_bytes s)
== { definition of le_bytes_to_seq_quad32 }
seq_to_seq_four_LE (seq_nat8_to_seq_nat32_LE (le_seq_quad32_to_bytes s))
=... | val le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s)
let le_bytes_to_seq_quad32_to_bytes (s: seq quad32)
: Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s) = | false | null | true | reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
le_seq_quad32_to_bytes_reveal ();
seq_to_seq_four_to_seq_LE (seq_map (nat_to_four 8) (seq_four_to_seq_LE s));
seq_map_inverses (nat_to_four 8) (four_to_nat 8) (seq_four_to_seq_LE s);
seq_to_seq_four_to_seq_LE (s);
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.seq_to_seq_four_to_seq_LE",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.f... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s) | [] | Vale.Arch.Types.le_bytes_to_seq_quad32_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_bytes_to_seq_quad32 (Vale.Def.Types_s.le_seq_quad32_to_bytes s) == s) | {
"end_col": 4,
"end_line": 380,
"start_col": 2,
"start_line": 375
} |
FStar.Pervasives.Lemma | val le_seq_quad32_to_bytes_injective (b b':Seq.seq quad32) : Lemma
(requires Seq.equal (le_seq_quad32_to_bytes b) (le_seq_quad32_to_bytes b'))
(ensures b == b') | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_seq_quad32_to_bytes_injective (b b':seq quad32) =
le_seq_quad32_to_bytes_reveal ();
seq_four_to_seq_LE_injective nat8;
nat_to_four_8_injective();
seq_map_injective (nat_to_four 8) (seq_four_to_seq_LE b) (seq_four_to_seq_LE b');
seq_four_to_seq_LE_injective_specific b b';
assert (equal b b') | val le_seq_quad32_to_bytes_injective (b b':Seq.seq quad32) : Lemma
(requires Seq.equal (le_seq_quad32_to_bytes b) (le_seq_quad32_to_bytes b'))
(ensures b == b')
let le_seq_quad32_to_bytes_injective (b b': seq quad32) = | false | null | true | le_seq_quad32_to_bytes_reveal ();
seq_four_to_seq_LE_injective nat8;
nat_to_four_8_injective ();
seq_map_injective (nat_to_four 8) (seq_four_to_seq_LE b) (seq_four_to_seq_LE b');
seq_four_to_seq_LE_injective_specific b b';
assert (equal b b') | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.unit",
"Vale.Def.Words.Seq.seq_four_to_seq_LE_injective_specific",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_injective",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val le_seq_quad32_to_bytes_injective (b b':Seq.seq quad32) : Lemma
(requires Seq.equal (le_seq_quad32_to_bytes b) (le_seq_quad32_to_bytes b'))
(ensures b == b') | [] | Vale.Arch.Types.le_seq_quad32_to_bytes_injective | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> b': FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.equal (Vale.Def.Types_s.le_seq_quad32_to_bytes b)
(Vale.Def.Types_s.le_seq_quad32_to_bytes b')) (ensures b == b') | {
"end_col": 21,
"end_line": 515,
"start_col": 2,
"start_line": 510
} |
FStar.Pervasives.Lemma | val le_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_bytes_to_seq_quad32_empty () :
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0)
=
reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
() | val le_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0)
let le_bytes_to_seq_quad32_empty ()
: Lemma
(forall s. {:pattern (length (le_bytes_to_seq_quad32 s))}
length s == 0 ==> length (le_bytes... | false | null | true | reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.quad32",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.l_True",
"Vale.Def.Types_s.le_bytes_to_seq_quad32",
"Prims.squash",
"Prims.l_Forall",
"Pri... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0) | [] | Vale.Arch.Types.le_bytes_to_seq_quad32_empty | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (s: FStar.Seq.Base.seq Vale.Def.Types_s.nat8).
{:pattern FStar.Seq.Base.length (Vale.Def.Types_s.le_bytes_to_seq_quad32 s)}
FStar.Seq.Base.length s == 0 ==>
FStar.Seq.Base.length (Vale.Def.Types_s.le_bytes_to_seq_quad32 s) == 0) | {
"end_col": 4,
"end_line": 314,
"start_col": 2,
"start_line": 313
} |
FStar.Pervasives.Lemma | val lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3)) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3))
=
let open Vale.Def.Words.Two in
let z = insert_nat64 x (lo64 y) 0 in
insert_n... | val lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3))
let lemma_insrq_extrq_relations (x y: quad32)
: Lemma
(let z = insert_nat64 x ... | false | null | true | let open Vale.Def.Words.Two in
let z = insert_nat64 x (lo64 y) 0 in
insert_nat64_reveal ();
lo64_reveal ();
hi64_reveal ();
assert (z == insert_nat64_def x (lo64_def y) 0);
let Mktwo n1 n2 = two_select (four_to_two_two y) 0 in
nat_to_two_to_nat n1 n2;
let Mktwo n1 n2 = two_select (four_to_two_two y) 1 in
nat_to_two_to_... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.unit",
"Vale.Def.Words.Two.nat_to_two_to_nat",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words.Two_s.two_select",
"Vale.Def.Words.Four_s.four_to_two_two",
"Prims._assert",
"Prims.eq2",
"Vale.Def.Types_s.insert_nat64_de... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3)) | [] | Vale.Arch.Types.lemma_insrq_extrq_relations | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.quad32 -> y: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
(let z = Vale.Def.Types_s.insert_nat64 x (Vale.Arch.Types.lo64 y) 0 in
z == Vale.Def.Words_s.Mkfour (Mkfour?.lo0 y) (Mkfour?.lo1 y) (Mkfour?.hi2 x) (Mkfour?.hi3 x) /\
(let z = Vale.Def.Types_s.insert_... | {
"end_col": 4,
"end_line": 297,
"start_col": 2,
"start_line": 280
} |
FStar.Pervasives.Lemma | val le_bytes_to_nat64_to_bytes (s:nat64) :
Lemma (le_bytes_to_nat64 (le_nat64_to_bytes s) == s) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_bytes_to_nat64_to_bytes s =
le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | val le_bytes_to_nat64_to_bytes (s:nat64) :
Lemma (le_bytes_to_nat64 (le_nat64_to_bytes s) == s)
let le_bytes_to_nat64_to_bytes s = | false | null | true | le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.nat64",
"Vale.Def.Types_s.le_bytes_to_nat64_reveal",
"Prims.unit",
"Vale.Def.Types_s.le_nat64_to_bytes_reveal"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_bytes_to_nat64_to_bytes (s:nat64) :
Lemma (le_bytes_to_nat64 (le_nat64_to_bytes s) == s) | [] | Vale.Arch.Types.le_bytes_to_nat64_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.Def.Words_s.nat64
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_bytes_to_nat64 (Vale.Def.Types_s.le_nat64_to_bytes s) == s) | {
"end_col": 29,
"end_line": 303,
"start_col": 2,
"start_line": 302
} |
FStar.Pervasives.Lemma | val lemma_lo64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern lo64 q0; lo64 q1}
(q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo64 q1)) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_lo64_properties (_:unit) :
Lemma (forall (q0 q1:quad32) . (q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo64 q1))
=
lo64_reveal ();
let helper (q0 q1:quad32) : Lemma ((q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo64 q1)) =
let Mktwo n1 n2 = two_select (four_to_two_two q0) 0 i... | val lemma_lo64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern lo64 q0; lo64 q1}
(q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo64 q1))
let lemma_lo64_properties (_: unit)
: Lemma
(forall (q0: quad32) (q1: quad32).
(q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo6... | false | null | true | lo64_reveal ();
let helper (q0 q1: quad32)
: Lemma ((q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo64 q1)) =
let Mktwo n1 n2 = two_select (four_to_two_two q0) 0 in
nat_to_two_to_nat n1 n2;
let Mktwo n1 n2 = two_select (four_to_two_two q1) 0 in
nat_to_two_to_nat n1 n2;
()
in
FStar.Classical.fora... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_iff",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.nat64",
"Vale.Arch.Types.lo64",
"Prims.l... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_lo64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern lo64 q0; lo64 q1}
(q0.lo0 == q1.lo0 /\ q0.lo1 == q1.lo1) <==> (lo64 q0 == lo64 q1)) | [] | Vale.Arch.Types.lemma_lo64_properties | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (q0: Vale.Def.Types_s.quad32) (q1: Vale.Def.Types_s.quad32).
{:pattern Vale.Arch.Types.lo64 q0; Vale.Arch.Types.lo64 q1}
Mkfour?.lo0 q0 == Mkfour?.lo0 q1 /\ Mkfour?.lo1 q0 == Mkfour?.lo1 q1 <==>
Vale.Arch.Types.lo64 q0 == Vale.A... | {
"end_col": 4,
"end_line": 179,
"start_col": 2,
"start_line": 170
} |
FStar.Pervasives.Lemma | val lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 ) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 )
=
let open Vale.Def.Words.Two in
insert_nat64_reveal ();
() | val lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 )
let lemma_insert_nat64_nat32s (q: quad32) (n0 n1: nat32)
: Lemma
... | false | null | true | let open Vale.Def.Words.Two in
insert_nat64_reveal ();
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Vale.Def.Types_s.insert_nat64_reveal",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.Def.Types_s.insert_nat64",
"Vale.Arch.Types.two_to_nat32",
"Vale.Def... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 ) | [] | Vale.Arch.Types.lemma_insert_nat64_nat32s | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32 -> n0: Vale.Def.Words_s.nat32 -> n1: Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.insert_nat64 q
(Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo n0 n1))
0 ==
Vale.Def.Words_s.Mkfour n0 n1 (Mkfour?.hi2 q) (Mkfour?.hi3 q) /\
... | {
"end_col": 4,
"end_line": 165,
"start_col": 2,
"start_line": 163
} |
FStar.Pervasives.Lemma | val be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
[SMTPat (be_bytes_to_quad32 (be_quad32_to_bytes q))] | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
=
be_bytes_to_quad32_reveal ();
let q':quad32 = be_bytes_to_quad32 (be_quad32_to_bytes q) in
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (four_to_seq_BE q));
seq_map_inverses (nat_to_four 8) (four_to_n... | val be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
[SMTPat (be_bytes_to_quad32 (be_quad32_to_bytes q))]
let be_bytes_to_quad32_to_bytes (q: quad32) : Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q) = | false | null | true | be_bytes_to_quad32_reveal ();
let q':quad32 = be_bytes_to_quad32 (be_quad32_to_bytes q) in
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (four_to_seq_BE q));
seq_map_inverses (nat_to_four 8) (four_to_nat 8) (four_to_seq_BE q);
seq_to_four_to_seq_BE q;
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.seq_to_four_to_seq_BE",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.four_to_nat",
"Vale.Def.Wor... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
[SMTPat (be_bytes_to_quad32 (be_quad32_to_bytes q))] | [] | Vale.Arch.Types.be_bytes_to_quad32_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.be_bytes_to_quad32 (Vale.Arch.Types.be_quad32_to_bytes q) == q)
[SMTPat (Vale.Def.Types_s.be_bytes_to_quad32 (Vale.Arch.Types.be_quad32_to_bytes q))] | {
"end_col": 4,
"end_line": 578,
"start_col": 2,
"start_line": 573
} |
FStar.Pervasives.Lemma | val slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n')) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n'))
=
reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
assert (equal (slice (s... | val slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n'))
let slice_commutes_seq_four_to_seq_BE
(#a: Type)
(s: seq (four a))
(n: nat{... | false | null | true | reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
assert (equal (slice (seq_four_to_seq_BE s) (n * 4) (n' * 4)) (seq_four_to_seq_BE (slice s n n')));
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"FStar.Mul.op_Star",
"FStar... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n')) | [] | Vale.Arch.Types.slice_commutes_seq_four_to_seq_BE | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
Vale.Def.Words.S... | {
"end_col": 4,
"end_line": 630,
"start_col": 2,
"start_line": 627
} |
FStar.Pervasives.Lemma | val lemma_nat_to_two32 (_:unit) : Lemma
(forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x100000000) (x / 0x100000000)) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x100000000) (x / 0x100000000)) | val lemma_nat_to_two32 (_:unit) : Lemma
(forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x100000000) (x / 0x100000000))
let lemma_nat_to_two32 () = | false | null | true | assert_norm (forall (x: nat64). {:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x100000000) (x / 0x100000000)) | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.l_Forall",
"Vale.Def.Words_s.nat64",
"Prims.eq2",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Two_s.nat_to_two",
"Vale.Def.Words_s.Mktwo",
"Prims.op_Modulus",
"Prims.op_Division"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_nat_to_two32 (_:unit) : Lemma
(forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x100000000) (x / 0x100000000)) | [] | Vale.Arch.Types.lemma_nat_to_two32 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (x: Vale.Def.Words_s.nat64). {:pattern Vale.Def.Words.Two_s.nat_to_two 32 x}
Vale.Def.Words.Two_s.nat_to_two 32 x ==
Vale.Def.Words_s.Mktwo (x % 0x100000000) (x / 0x100000000)) | {
"end_col": 65,
"end_line": 14,
"start_col": 2,
"start_line": 13
} |
FStar.Pervasives.Lemma | val lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))] | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))]
=
seq_map_inverses reverse_bytes_nat32_quad32 reverse_bytes_nat32_quad32 s | val lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))]
let lemma_reverse_reverse_bytes_nat32_quad32_seq (s: seq quad32)
: Lemma (reverse_bytes_na... | false | null | true | seq_map_inverses reverse_bytes_nat32_quad32 reverse_bytes_nat32_quad32 s | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Arch.Types.reverse_bytes_nat32_quad32",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Arch.Types.reverse_bytes_nat32_quad32_seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasi... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))] | [] | Vale.Arch.Types.lemma_reverse_reverse_bytes_nat32_quad32_seq | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.reverse_bytes_nat32_quad32_seq (Vale.Arch.Types.reverse_bytes_nat32_quad32_seq
s) ==
s)
[
SMTPat (Vale.Arch.Types.reverse_bytes_nat32_quad32_seq (Vale.Arch.Types.reverse_b... | {
"end_col": 74,
"end_line": 596,
"start_col": 2,
"start_line": 596
} |
FStar.Pervasives.Lemma | val be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s)
=
reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (seq_four_to_seq_BE s));
seq_map_inverses (nat_to_fou... | val be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s)
let be_bytes_to_seq_quad32_to_bytes (s: seq quad32)
: Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s) = | false | null | true | reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (seq_four_to_seq_BE s));
seq_map_inverses (nat_to_four 8) (four_to_nat 8) (seq_four_to_seq_BE s);
seq_to_seq_four_to_seq_BE (s);
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.seq_to_seq_four_to_seq_BE",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.f... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s) | [] | Vale.Arch.Types.be_bytes_to_seq_quad32_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.be_bytes_to_seq_quad32 (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE
s)) ==
s) | {
"end_col": 4,
"end_line": 389,
"start_col": 2,
"start_line": 385
} |
FStar.Pervasives.Lemma | val seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s)
=
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (create 1 (seq_to_four_LE s)) (seq_to_seq_four_LE s));
() | val seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s)
let seq_to_four_LE_is_seq_to_seq_four_LE (#a: Type) (s: seq4 a)
: Lemma (create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s) = | false | null | true | reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (create 1 (seq_to_four_LE s)) (seq_to_seq_four_LE s));
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words.Seq_s.seq4",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words_s.four",
"FStar.Seq.Base.create",
"Vale.Def.Words.Seq_s.seq_to_four_LE",
"Vale.Def.Words.Seq_s.seq_to_seq_four_LE",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.in... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s) | [] | Vale.Arch.Types.seq_to_four_LE_is_seq_to_seq_four_LE | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.Def.Words.Seq_s.seq4 a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.create 1 (Vale.Def.Words.Seq_s.seq_to_four_LE s) ==
Vale.Def.Words.Seq_s.seq_to_seq_four_LE s) | {
"end_col": 4,
"end_line": 522,
"start_col": 2,
"start_line": 520
} |
FStar.Pervasives.Lemma | val le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q)
=
le_seq_quad32_to_bytes_of_singleton q; // ==> le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)
let b = le_quad32_to_bytes q in
let q' = le_bytes_to_quad32 b in
le_bytes_to_seq_quad_of_singleton q... | val le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q)
let le_bytes_to_quad32_to_bytes (q: quad32) : Lemma (le_bytes_to_quad32 (le_quad32_to_bytes q) == q) = | false | null | true | le_seq_quad32_to_bytes_of_singleton q;
let b = le_quad32_to_bytes q in
let q' = le_bytes_to_quad32 b in
le_bytes_to_seq_quad_of_singleton q' b;
le_bytes_to_seq_quad32_to_bytes (create 1 q);
assert (q == index (create 1 q) 0);
assert (q == q');
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Seq.Base.create",
"Vale.Arch.Types.le_bytes_to_seq_quad32_to_bytes",
"Vale.Arch.Types.le_bytes_to_seq_quad_of_singleton",
"Vale.Def.Types_s.le_bytes_to_quad32",
"FStar.Seq.Base.seq",
"Vale.Def.W... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q) | [] | Vale.Arch.Types.le_bytes_to_quad32_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_bytes_to_quad32 (Vale.Def.Types_s.le_quad32_to_bytes q) == q) | {
"end_col": 4,
"end_line": 568,
"start_col": 2,
"start_line": 558
} |
FStar.Pervasives.Lemma | val be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b)
=
reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
be_bytes_to_quad32_reveal ();
seq_to_four_BE_is_seq_to_seq_four_BE... | val be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b)
let be_bytes_to_seq_quad_of_singleton (q: quad32) (b: seq nat8 {length b == 16})
: Lemma (requires q == be_bytes_to_quad32 b) (ensures cr... | false | null | true | reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
be_bytes_to_quad32_reveal ();
seq_to_four_BE_is_seq_to_seq_four_BE (seq_map (four_to_nat 8) (seq_to_seq_four_BE b));
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"Vale.Arch.Types.seq_to_four_BE_is_seq_to_seq_four_BE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Lib.Seqs_s.seq_map",
"Vale.Def.... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b) | [] | Vale.Arch.Types.be_bytes_to_seq_quad_of_singleton | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
q: Vale.Def.Types_s.quad32 ->
b: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length b == 16}
-> FStar.Pervasives.Lemma (requires q == Vale.Def.Types_s.be_bytes_to_quad32 b)
(ensures FStar.Seq.Base.create 1 q == Vale.Def.Types_s.be_bytes_to_seq_quad32 b) | {
"end_col": 4,
"end_line": 553,
"start_col": 2,
"start_line": 550
} |
FStar.Pervasives.Lemma | val slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n)) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n))
=
slice_commutes_le_seq_quad32_to_bytes s 0 n | val slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n))
let slice_commutes_le_seq_quad32_to_bytes0 (s: seq quad32) (n: nat{n <= length s})
: Lemma (slice (le_seq_quad32_to_bytes s) 0 (n * ... | false | null | true | slice_commutes_le_seq_quad32_to_bytes s 0 n | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Vale.Arch.Types.slice_commutes_le_seq_quad32_to_bytes",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Types_s.nat8",
"FStar.Seq.Base.slice",... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n)) | [] | Vale.Arch.Types.slice_commutes_le_seq_quad32_to_bytes0 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> n: Prims.nat{n <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Types_s.le_seq_quad32_to_bytes s) 0 (n * 16) ==
Vale.Def.Types_s.le_seq_quad32_to_bytes (FStar.Seq.Base.slice s 0 n)) | {
"end_col": 45,
"end_line": 668,
"start_col": 2,
"start_line": 668
} |
FStar.Pervasives.Lemma | val le_nat64_to_bytes_to_nat64 (s:seq nat8 { length s == 8 }) :
Lemma (le_nat64_to_bytes (le_bytes_to_nat64 s) == s) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_nat64_to_bytes_to_nat64 n =
le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | val le_nat64_to_bytes_to_nat64 (s:seq nat8 { length s == 8 }) :
Lemma (le_nat64_to_bytes (le_bytes_to_nat64 s) == s)
let le_nat64_to_bytes_to_nat64 n = | false | null | true | le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.le_bytes_to_nat64_reveal",
"Prims.unit",
"Vale.Def.Types_s.le_nat64_to_bytes_reveal"
] | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_nat64_to_bytes_to_nat64 (s:seq nat8 { length s == 8 }) :
Lemma (le_nat64_to_bytes (le_bytes_to_nat64 s) == s) | [] | Vale.Arch.Types.le_nat64_to_bytes_to_nat64 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s == 8}
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_nat64_to_bytes (Vale.Def.Types_s.le_bytes_to_nat64 s) == s) | {
"end_col": 29,
"end_line": 307,
"start_col": 2,
"start_line": 306
} |
FStar.Pervasives.Lemma | val le_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let le_quad32_to_bytes_injective ():
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b')
=
reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
let helper (b b':quad32) : Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') =
if le_quad32_to_bytes b = le_quad32_t... | val le_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b')
let le_quad32_to_bytes_injective ()
: Lemma (forall b b'. le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') = | false | null | true | reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
let helper (b b': quad32) : Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') =
if le_quad32_to_bytes b = le_quad32_to_bytes b'
then
(let b1 = seq_map (nat_to_four 8) (four_to_seq_LE b) in
let b1' = seq_map (nat_to_four 8) (four_to_s... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_imp",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Vale.Def.Words_s.nat8",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Pr... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val le_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | [] | Vale.Arch.Types.le_quad32_to_bytes_injective | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (b: Vale.Def.Types_s.quad32) (b': Vale.Def.Types_s.quad32).
Vale.Def.Types_s.le_quad32_to_bytes b == Vale.Def.Types_s.le_quad32_to_bytes b' ==> b == b') | {
"end_col": 39,
"end_line": 475,
"start_col": 2,
"start_line": 458
} |
FStar.Pervasives.Lemma | val push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x') | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x')
=
// assert (nat_to_two 32 (hi64 x) == two_select (four_to_two_two x) 1);
insert_nat64_reveal ();
lo64_reveal ();
hi64_reveal ();
() | val push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x')
let push_pop_xmm (x y: quad32)
: Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x') = | false | null | true | insert_nat64_reveal ();
lo64_reveal ();
hi64_reveal ();
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Arch.Types.hi64_reveal",
"Vale.Arch.Types.lo64_reveal",
"Vale.Def.Types_s.insert_nat64_reveal",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Types_s.insert_nat64",
"Vale.Arch.Types.hi64",
"Vale.Arch.Types.lo64",
"Prims.Nil",
"FStar.Per... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x') | [] | Vale.Arch.Types.push_pop_xmm | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.quad32 -> y: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
(let x' =
Vale.Def.Types_s.insert_nat64 (Vale.Def.Types_s.insert_nat64 y (Vale.Arch.Types.hi64 x) 1)
(Vale.Arch.Types.lo64 x)
0
in
x == x')) | {
"end_col": 4,
"end_line": 271,
"start_col": 2,
"start_line": 268
} |
FStar.Pervasives.Lemma | val slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n')) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n'))
=
le_seq_quad32_to_bytes_reveal ();
slice_commutes_seq_four_to_seq_LE s n n';
asser... | val slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n'))
let slice_commutes_le_seq_quad32_to_bytes
(s: seq quad32)
(n: nat{n <= length s... | false | null | true | le_seq_quad32_to_bytes_reveal ();
slice_commutes_seq_four_to_seq_LE s n n';
assert (slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) == seq_four_to_seq_LE (slice s n n'));
slice_seq_map_commute (nat_to_four 8) (seq_four_to_seq_LE s) (n * 4) (n' * 4);
let s_inner = (seq_map (nat_to_four 8) (seq_four_to_seq_LE s)) in
slice_... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Vale.Arch.Types.slice_commutes_seq_four_to_seq_LE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.four... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n')) | [] | Vale.Arch.Types.slice_commutes_le_seq_quad32_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Types_s.le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
Vale.Def.Types_s... | {
"end_col": 4,
"end_line": 650,
"start_col": 2,
"start_line": 636
} |
FStar.Pervasives.Lemma | val slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n'))) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n')))
=
slice_commutes_seq_four_to_seq_BE s n n... | val slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n')))
let slice_commutes_be_seq_quad32_to_bytes
... | false | null | true | slice_commutes_seq_four_to_seq_BE s n n';
assert (slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) == seq_four_to_seq_BE (slice s n n'));
slice_seq_map_commute (nat_to_four 8) (seq_four_to_seq_BE s) (n * 4) (n' * 4);
let s_inner = (seq_map (nat_to_four 8) (seq_four_to_seq_BE s)) in
slice_commutes_seq_four_to_seq_BE s_inne... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Vale.Arch.Types.slice_commutes_seq_four_to_seq_BE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.four... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n'))) | [] | Vale.Arch.Types.slice_commutes_be_seq_quad32_to_bytes | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE
... | {
"end_col": 4,
"end_line": 662,
"start_col": 2,
"start_line": 656
} |
FStar.Pervasives.Lemma | val slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n')) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n'))
=
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
assert (equal (slice (s... | val slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n'))
let slice_commutes_seq_four_to_seq_LE
(#a: Type)
(s: seq (four a))
(n: nat{... | false | null | true | reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
assert (equal (slice (seq_four_to_seq_LE s) (n * 4) (n' * 4)) (seq_four_to_seq_LE (slice s n n')));
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Vale.Def.Words.Seq_s.seq_four_to_seq_LE",
"FStar.Mul.op_Star",
"FStar... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n')) | [] | Vale.Arch.Types.slice_commutes_seq_four_to_seq_LE | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
Vale.Def.Words.S... | {
"end_col": 4,
"end_line": 621,
"start_col": 2,
"start_line": 618
} |
FStar.Pervasives.Lemma | val be_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let be_quad32_to_bytes_injective ():
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b')
=
reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
let helper (b b':quad32) : Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') =
if be_quad32_to_bytes b = be_quad32_t... | val be_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b')
let be_quad32_to_bytes_injective ()
: Lemma (forall b b'. be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') = | false | null | true | reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
let helper (b b': quad32) : Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') =
if be_quad32_to_bytes b = be_quad32_to_bytes b'
then
(let b1 = seq_map (nat_to_four 8) (four_to_seq_BE b) in
let b1' = seq_map (nat_to_four 8) (four_to_s... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Words_s.nat8",
"Vale.Arch.Types.be_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_Equality",
... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val be_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | [] | Vale.Arch.Types.be_quad32_to_bytes_injective | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (b: Vale.Def.Types_s.quad32) (b': Vale.Def.Types_s.quad32).
Vale.Arch.Types.be_quad32_to_bytes b == Vale.Arch.Types.be_quad32_to_bytes b' ==> b == b') | {
"end_col": 39,
"end_line": 497,
"start_col": 2,
"start_line": 480
} |
FStar.Pervasives.Lemma | val append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2)) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2))
=
reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
let s1' = seq_nat8... | val append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2))
let append_distributes_le_bytes_to_seq_quad32
(s1: seq nat8 {length s1 % 16 == 0})
... | false | null | true | reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
let s1' = seq_nat8_to_seq_nat32_LE s1 in
let s2' = seq_nat8_to_seq_nat32_LE s2 in
append_distributes_seq_to_seq_four_LE s1' s2';
append_distributes_seq_map (four_to_nat 8) (seq_to_seq_four_LE s1) (seq_to_seq_four_LE s2);
append_distributes_seq_to_seq_four... | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Vale.Def.Words.Seq.append_distributes_seq_to_seq_four_LE",
"Vale.Lib.Seqs.append_distributes_seq_map",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.p... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | null | val append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2)) | [] | Vale.Arch.Types.append_distributes_le_bytes_to_seq_quad32 | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s1: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s1 % 16 == 0} ->
s2: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s2 % 16 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_bytes_to_seq_quad32 (s1 @| s2) ==
Vale.Def.Types_s.le_bytes_to_seq_quad... | {
"end_col": 4,
"end_line": 694,
"start_col": 2,
"start_line": 680
} |
FStar.Pervasives.Lemma | val lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | val lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | false | null | true | lo64_reveal ();
hi64_reveal ();
assert (forall (x: two nat32). {:pattern (two_to_nat 32 x)}
two_to_nat 32 x == two_to_nat_unfold 32 x);
() | {
"checked_file": "Vale.Arch.Types.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"Prims.l_Forall",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.nat32",
"Prims.eq2",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words.Two_s.two_to_nat",
"Vale.Def.Words.Two_s.two_to_nat_unfold",
"Vale.Arch.Types... | [] | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | false | false | Vale.Arch.Types.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | [] | Vale.Arch.Types.lemma_equality_check_helper | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
(Mkfour?.lo0 q == 0 /\ Mkfour?.lo1 q == 0 ==> Vale.Arch.Types.lo64 q == 0) /\
(Prims.op_Negation (Mkfour?.lo0 q = 0) \/ Prims.op_Negation (Mkfour?.lo1 q = 0) ==>
Prims.op_Negation (Vale.Arch.Types.lo64 q = 0)) /\
(Mkfour?.hi2 ... | {
"end_col": 4,
"end_line": 260,
"start_col": 2,
"start_line": 257
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.