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.Tot | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_elems4_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max / 4}) = a & s:seq t{length s == 4 * i} | let generate_elems4_a (t a: Type0) (max: nat) (i: nat{i <= max / 4}) = | false | null | false | a & s: seq t {length s == 4 * i} | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star"
] | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_elems4_a : t: Type0 -> a: Type0 -> max: Prims.nat -> i: Prims.nat{i <= max / 4} -> Type0 | [] | Hacl.Spec.Lib.generate_elems4_a | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Type0 -> a: Type0 -> max: Prims.nat -> i: Prims.nat{i <= max / 4} -> Type0 | {
"end_col": 106,
"end_line": 74,
"start_col": 76,
"start_line": 74
} | |
Prims.Tot | val generate_elems:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Tot (a & s:seq t{length s == n}) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_elems #t #a max n f init =
let init2 : generate_elem_a t a max 0 = (init, Seq.empty) in
Loops.repeat_gen n (generate_elem_a t a max) (generate_elem_f max f) init2 | val generate_elems:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Tot (a & s:seq t{length s == n})
let generate_elems #t #a max n f init = | false | null | false | let init2:generate_elem_a t a max 0 = (init, Seq.empty) in
Loops.repeat_gen n (generate_elem_a t a max) (generate_elem_f max f) init2 | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repeat_gen",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.le... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_elems:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Tot (a & s:seq t{length s == n}) | [] | Hacl.Spec.Lib.generate_elems | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | max: Prims.nat -> n: Prims.nat{n <= max} -> f: (i: Prims.nat{i < max} -> _: a -> a * t) -> init: a
-> a * s: Lib.Sequence.seq t {Lib.Sequence.length s == n} | {
"end_col": 76,
"end_line": 41,
"start_col": 39,
"start_line": 39
} |
Prims.Tot | val generate_elems_unroll4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Tot (a & s:seq t{length s == n}) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_elems_unroll4 #t #a max n f init =
let (c0, res0) = Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
let (c1, res1) = Loops.repeat_right (n / 4 * 4) n (generate_elem_a t a max) (generate_elem_f max f) (c0, res0) in
(c1, res1) | val generate_elems_unroll4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Tot (a & s:seq t{length s == n})
let generate_elems_unroll4 #t #a max n f init = | false | null | false | let c0, res0 =
Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty)
in
let c1, res1 =
Loops.repeat_right ((n / 4) * 4) n (generate_elem_a t a max) (generate_elem_f max f) (c0, res0)
in
(c1, res1) | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star",
"Prims.op_Division",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Lib.generate_elem_a",
"... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_elems_unroll4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Tot (a & s:seq t{length s == n}) | [] | Hacl.Spec.Lib.generate_elems_unroll4 | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | max: Prims.nat -> n: Prims.nat{n <= max} -> f: (i: Prims.nat{i < max} -> _: a -> a * t) -> init: a
-> a * s: Lib.Sequence.seq t {Lib.Sequence.length s == n} | {
"end_col": 12,
"end_line": 110,
"start_col": 47,
"start_line": 107
} |
FStar.Pervasives.Lemma | val eq_generate_elems0:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma (generate_elems #t #a max 0 f init == (init, Seq.empty)) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let eq_generate_elems0 #t #a max n f init =
let init2 : generate_elem_a t a max 0 = (init, Seq.empty) in
Loops.eq_repeat_gen0 n (generate_elem_a t a max) (generate_elem_f max f) init2 | val eq_generate_elems0:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma (generate_elems #t #a max 0 f init == (init, Seq.empty))
let eq_generate_elems0 #t #a max n f init = | false | null | true | let init2:generate_elem_a t a max 0 = (init, Seq.empty) in
Loops.eq_repeat_gen0 n (generate_elem_a t a max) (generate_elem_f max f) init2 | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.eq_repeat_gen0",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequenc... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 eq_generate_elems0:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma (generate_elems #t #a max 0 f init == (init, Seq.empty)) | [] | Hacl.Spec.Lib.eq_generate_elems0 | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | max: Prims.nat -> n: Prims.nat{n <= max} -> f: (i: Prims.nat{i < max} -> _: a -> a * t) -> init: a
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Lib.generate_elems max 0 f init ==
FStar.Pervasives.Native.Mktuple2 init FStar.Seq.Base.empty) | {
"end_col": 80,
"end_line": 55,
"start_col": 43,
"start_line": 53
} |
Prims.Tot | val generate_elem_f:
#t:Type0
-> #a:Type0
-> max:nat
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < max}
-> acc:generate_elem_a t a max i ->
generate_elem_a t a max (i + 1) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_elem_f #t #a max f i (c, res) =
let c', e = f i c in
let res' = Seq.snoc res e in
c', res' | val generate_elem_f:
#t:Type0
-> #a:Type0
-> max:nat
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < max}
-> acc:generate_elem_a t a max i ->
generate_elem_a t a max (i + 1)
let generate_elem_f #t #a max f i (c, res) = | false | null | false | let c', e = f i c in
let res' = Seq.snoc res e in
c', res' | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elem_a",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.snoc"
] | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_elem_f:
#t:Type0
-> #a:Type0
-> max:nat
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < max}
-> acc:generate_elem_a t a max i ->
generate_elem_a t a max (i + 1) | [] | Hacl.Spec.Lib.generate_elem_f | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
max: Prims.nat ->
f: (i: Prims.nat{i < max} -> _: a -> a * t) ->
i: Prims.nat{i < max} ->
acc: Hacl.Spec.Lib.generate_elem_a t a max i
-> Hacl.Spec.Lib.generate_elem_a t a max (i + 1) | {
"end_col": 10,
"end_line": 27,
"start_col": 44,
"start_line": 24
} |
FStar.Pervasives.Lemma | val generate_elems_unfold:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a
-> i:nat{i < n} -> Lemma
(generate_elems #t #a max (i + 1) f init ==
generate_elem_f max f i (generate_elems #t #a max i f init)) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_elems_unfold #t #a max n f init i =
let init2 : generate_elem_a t a max 0 = (init, Seq.empty) in
Loops.unfold_repeat_gen (i + 1) (generate_elem_a t a max) (generate_elem_f max f) init2 i | val generate_elems_unfold:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a
-> i:nat{i < n} -> Lemma
(generate_elems #t #a max (i + 1) f init ==
generate_elem_f max f i (generate_elems #t #a max i f init))
let generate_elems_unfold #t #a max n f init ... | false | null | true | let init2:generate_elem_a t a max 0 = (init, Seq.empty) in
Loops.unfold_repeat_gen (i + 1) (generate_elem_a t a max) (generate_elem_f max f) init2 i | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.unfold_repeat_gen",
"Prims.op_Addition",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.seq",
"... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_elems_unfold:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a
-> i:nat{i < n} -> Lemma
(generate_elems #t #a max (i + 1) f init ==
generate_elem_f max f i (generate_elems #t #a max i f init)) | [] | Hacl.Spec.Lib.generate_elems_unfold | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
max: Prims.nat ->
n: Prims.nat{n <= max} ->
f: (i: Prims.nat{i < max} -> _: a -> a * t) ->
init: a ->
i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Lib.generate_elems max (i + 1) f init ==
Hacl.Spec.Lib.generate_elem_f max f i (Hacl.Spec.Lib.generate_elems max i... | {
"end_col": 91,
"end_line": 71,
"start_col": 48,
"start_line": 69
} |
Prims.Tot | val generate_elems4_f:
#t:Type0
-> #a:Type0
-> max:nat
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < max / 4}
-> acc:generate_elems4_a t a max i ->
generate_elems4_a t a max (i + 1) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_elems4_f #t #a max f i (c, res) =
let c0, e0 = f (4 * i) c in
let c1, e1 = f (4 * i + 1) c0 in
let c2, e2 = f (4 * i + 2) c1 in
let c3, e3 = f (4 * i + 3) c2 in
let res0 = Seq.snoc res e0 in
let res1 = Seq.snoc res0 e1 in
let res2 = Seq.snoc res1 e2 in
let res3 = Seq.snoc res2 e3 in
c3, ... | val generate_elems4_f:
#t:Type0
-> #a:Type0
-> max:nat
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < max / 4}
-> acc:generate_elems4_a t a max i ->
generate_elems4_a t a max (i + 1)
let generate_elems4_f #t #a max f i (c, res) = | false | null | false | let c0, e0 = f (4 * i) c in
let c1, e1 = f (4 * i + 1) c0 in
let c2, e2 = f (4 * i + 2) c1 in
let c3, e3 = f (4 * i + 3) c2 in
let res0 = Seq.snoc res e0 in
let res1 = Seq.snoc res0 e1 in
let res2 = Seq.snoc res1 e2 in
let res3 = Seq.snoc res2 e3 in
c3, res3 | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Division",
"Hacl.Spec.Lib.generate_elems4_a",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"FStar... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_elems4_f:
#t:Type0
-> #a:Type0
-> max:nat
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < max / 4}
-> acc:generate_elems4_a t a max i ->
generate_elems4_a t a max (i + 1) | [] | Hacl.Spec.Lib.generate_elems4_f | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
max: Prims.nat ->
f: (i: Prims.nat{i < max} -> _: a -> a * t) ->
i: Prims.nat{i < max / 4} ->
acc: Hacl.Spec.Lib.generate_elems4_a t a max i
-> Hacl.Spec.Lib.generate_elems4_a t a max (i + 1) | {
"end_col": 10,
"end_line": 95,
"start_col": 46,
"start_line": 85
} |
Prims.Tot | val generate_blocks4_f:
#t:Type0
-> #a:Type0
-> k:nat
-> f:(i:nat{i < 4 * k} -> a -> a & t)
-> i:nat{i < k}
-> c:a
-> tuple2 a (lseq t 4) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let generate_blocks4_f #t #a max f i c =
let c0, e0 = f (4 * i) c in
let c1, e1 = f (4 * i + 1) c0 in
let c2, e2 = f (4 * i + 2) c1 in
let c3, e3 = f (4 * i + 3) c2 in
c3, Lib.Sequence.create4 e0 e1 e2 e3 | val generate_blocks4_f:
#t:Type0
-> #a:Type0
-> k:nat
-> f:(i:nat{i < 4 * k} -> a -> a & t)
-> i:nat{i < k}
-> c:a
-> tuple2 a (lseq t 4)
let generate_blocks4_f #t #a max f i c = | false | null | false | let c0, e0 = f (4 * i) c in
let c1, e1 = f (4 * i + 1) c0 in
let c2, e2 = f (4 * i + 2) c1 in
let c3, e3 = f (4 * i + 3) c2 in
c3, Lib.Sequence.create4 e0 e1 e2 e3 | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.lseq",
"Lib.Sequence.create4",
"Prims.op_Addition"
] | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 generate_blocks4_f:
#t:Type0
-> #a:Type0
-> k:nat
-> f:(i:nat{i < 4 * k} -> a -> a & t)
-> i:nat{i < k}
-> c:a
-> tuple2 a (lseq t 4) | [] | Hacl.Spec.Lib.generate_blocks4_f | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Prims.nat -> f: (i: Prims.nat{i < 4 * k} -> _: a -> a * t) -> i: Prims.nat{i < k} -> c: a
-> a * Lib.Sequence.lseq t 4 | {
"end_col": 38,
"end_line": 191,
"start_col": 40,
"start_line": 186
} |
FStar.Pervasives.Lemma | val lemma_generate_elems_unroll4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma (generate_elems_unroll4 #t #a max n f init == generate_elems #t #a max n f init) | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let lemma_generate_elems_unroll4 #t #a max n f init =
let (c0, res0) = Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
let (c1, res1) = Loops.repeat_right (n / 4 * 4) n (generate_elem_a t a max) (generate_elem_f max f) (c0, res0) in
let (c2, res2) = Loops.repeat... | val lemma_generate_elems_unroll4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma (generate_elems_unroll4 #t #a max n f init == generate_elems #t #a max n f init)
let lemma_generate_elems_unroll4 #t #a max n f init = | false | null | true | let c0, res0 =
Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty)
in
let c1, res1 =
Loops.repeat_right ((n / 4) * 4) n (generate_elem_a t a max) (generate_elem_f max f) (c0, res0)
in
let c2, res2 =
Loops.repeat_gen n (generate_elem_a t a max) (generate_elem_f max f) (... | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Hacl.Spec.Lib.lemma_generate_elems_unroll4_loop",
"Prims.unit",
"Lib.... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 lemma_generate_elems_unroll4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma (generate_elems_unroll4 #t #a max n f init == generate_elems #t #a max n f init) | [] | Hacl.Spec.Lib.lemma_generate_elems_unroll4 | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | max: Prims.nat -> n: Prims.nat{n <= max} -> f: (i: Prims.nat{i < max} -> _: a -> a * t) -> init: a
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Lib.generate_elems_unroll4 max n f init == Hacl.Spec.Lib.generate_elems max n f init
) | {
"end_col": 64,
"end_line": 174,
"start_col": 53,
"start_line": 165
} |
FStar.Pervasives.Lemma | val lemma_generate_elems4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a -> Lemma
(let (c, res) = generate_elems #t #a max n f init in
let (c1, res1) = generate_blocks 4 (max / 4) (n / 4) (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init ... | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let lemma_generate_elems4 #t #a max n f init =
lemma_generate_elems4_loop #t #a max n f init;
lemma_generate_elems_unroll4 #t #a max n f init | val lemma_generate_elems4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a -> Lemma
(let (c, res) = generate_elems #t #a max n f init in
let (c1, res1) = generate_blocks 4 (max / 4) (n / 4) (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init ... | false | null | true | lemma_generate_elems4_loop #t #a max n f init;
lemma_generate_elems_unroll4 #t #a max n f init | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.lemma_generate_elems_unroll4",
"Prims.unit",
"Hacl.Spec.Lib.lemma_generate_elems4_loop"
] | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 lemma_generate_elems4:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a -> Lemma
(let (c, res) = generate_elems #t #a max n f init in
let (c1, res1) = generate_blocks 4 (max / 4) (n / 4) (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init ... | [] | Hacl.Spec.Lib.lemma_generate_elems4 | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | max: Prims.nat -> n: Prims.nat{n <= max} -> f: (i: Prims.nat{i < max} -> _: a -> a * t) -> init: a
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Lib.generate_elems max n f init in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
let _ =
Lib.Sequence.generate_blo... | {
"end_col": 49,
"end_line": 271,
"start_col": 2,
"start_line": 270
} |
FStar.Pervasives.Lemma | val lemma_generate_elems4_loop_step:
#t:Type0
-> #a:Type0
-> max:nat
-> k:nat{4 * k <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < k}
-> c:a
-> s:seq t{length s == 4 * i} ->
Lemma
(let (c1, res1) = generate_elems4_f #t #a max f i (c, s) in
let (c2, res2) = generate_blocks4_f #t #a k f... | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let lemma_generate_elems4_loop_step #t #a max k f i c s =
let (c1, res1) = generate_elems4_f #t #a max f i (c, s) in
let (c2, res2) = generate_blocks4_f #t #a k f i c in
let c0, e0 = f (4 * i) c in
let c1, e1 = f (4 * i + 1) c0 in
let c2, e2 = f (4 * i + 2) c1 in
let c3, e3 = f (4 * i + 3) c2 in
let res ... | val lemma_generate_elems4_loop_step:
#t:Type0
-> #a:Type0
-> max:nat
-> k:nat{4 * k <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < k}
-> c:a
-> s:seq t{length s == 4 * i} ->
Lemma
(let (c1, res1) = generate_elems4_f #t #a max f i (c, s) in
let (c2, res2) = generate_blocks4_f #t #a k f... | false | null | true | let c1, res1 = generate_elems4_f #t #a max f i (c, s) in
let c2, res2 = generate_blocks4_f #t #a k f i c in
let c0, e0 = f (4 * i) c in
let c1, e1 = f (4 * i + 1) c0 in
let c2, e2 = f (4 * i + 2) c1 in
let c3, e3 = f (4 * i + 3) c2 in
let res = Lib.Sequence.create4 e0 e1 e2 e3 in
let res0 = Seq.snoc s e0 in
let res1 = ... | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"Prims.op_Addition",
"Lib.Sequence.lseq",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Seq.Base.... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 lemma_generate_elems4_loop_step:
#t:Type0
-> #a:Type0
-> max:nat
-> k:nat{4 * k <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> i:nat{i < k}
-> c:a
-> s:seq t{length s == 4 * i} ->
Lemma
(let (c1, res1) = generate_elems4_f #t #a max f i (c, s) in
let (c2, res2) = generate_blocks4_f #t #a k f... | [] | Hacl.Spec.Lib.lemma_generate_elems4_loop_step | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
max: Prims.nat ->
k: Prims.nat{4 * k <= max} ->
f: (i: Prims.nat{i < max} -> _: a -> a * t) ->
i: Prims.nat{i < k} ->
c: a ->
s: Lib.Sequence.seq t {Lib.Sequence.length s == 4 * i}
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Lib.generate_elems4_f max f i (c, s) in
... | {
"end_col": 44,
"end_line": 222,
"start_col": 57,
"start_line": 208
} |
FStar.Pervasives.Lemma | val lemma_generate_elems4_loop:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a -> Lemma
(let (c1, res1) = generate_blocks 4 (max / 4) (n / 4) (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init in
let (c2, res2) = Loops.repeat_gen (n / 4) (g... | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let rec lemma_generate_elems4_loop #t #a max n f init =
let k = n / 4 in
let (c1, res1) = generate_blocks 4 (max / 4) k (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init in
let (c2, res2) = Loops.repeat_gen k (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
if k = 0 then b... | val lemma_generate_elems4_loop:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a -> Lemma
(let (c1, res1) = generate_blocks 4 (max / 4) (n / 4) (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init in
let (c2, res2) = Loops.repeat_gen (n / 4) (g... | false | null | true | let k = n / 4 in
let c1, res1 =
generate_blocks 4 (max / 4) k (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init
in
let c2, res2 =
Loops.repeat_gen k (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty)
in
if k = 0
then
(eq_generate_blocks0 4 (max / 4) (Loops.fixed_a a) (generate_blo... | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.fixed_a",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star",
"Prims.op_Equality",
"Lib.LoopCombinators.eq_repeat_gen0",
"... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 lemma_generate_elems4_loop:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a -> Lemma
(let (c1, res1) = generate_blocks 4 (max / 4) (n / 4) (Loops.fixed_a a) (generate_blocks4_f #t #a (max / 4) f) init in
let (c2, res2) = Loops.repeat_gen (n / 4) (g... | [
"recursion"
] | Hacl.Spec.Lib.lemma_generate_elems4_loop | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | max: Prims.nat -> n: Prims.nat{n <= max} -> f: (i: Prims.nat{i < max} -> _: a -> a * t) -> init: a
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.Sequence.generate_blocks 4
(max / 4)
(n / 4)
(Lib.LoopCombinators.fixed_a a)
(Hacl.Spec.Lib.generate_bl... | {
"end_col": 10,
"end_line": 254,
"start_col": 55,
"start_line": 236
} |
FStar.Pervasives.Lemma | val lemma_generate_elems_unroll4_loop:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max /\ n % 4 = 0}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma
(let (c0, res0) = Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
let (c1, res1) = Loop... | [
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"f... | false | let lemma_generate_elems_unroll4_loop #t #a max n f init =
let acc_v = Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
let acc = Loops.repeat_gen n (generate_elem_a t a max) (generate_elem_f max f) (init, Seq.empty) in
let normalize_v (i:nat{i <= n / 4}) (acc_v... | val lemma_generate_elems_unroll4_loop:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max /\ n % 4 = 0}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma
(let (c0, res0) = Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
let (c1, res1) = Loop... | false | null | true | let acc_v =
Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty)
in
let acc = Loops.repeat_gen n (generate_elem_a t a max) (generate_elem_f max f) (init, Seq.empty) in
let normalize_v (i: nat{i <= n / 4}) (acc_v: generate_elems4_a t a max i)
: generate_elem_a t a max (4... | {
"checked_file": "Hacl.Spec.Lib.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pe... | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repeat_gen_def",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Per... | [] | module Hacl.Spec.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module Loops = Lib.LoopCombinators
module VecLemmas = Lib.Vec.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let generate_elem_a (t:Type0) (a:Type0) (max:nat) (i:nat{i <= max}) = a & s:seq t{length s == i}
val generate_elem_f:
#... | false | false | Hacl.Spec.Lib.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 lemma_generate_elems_unroll4_loop:
#t:Type0
-> #a:Type0
-> max:nat
-> n:nat{n <= max /\ n % 4 = 0}
-> f:(i:nat{i < max} -> a -> a & t)
-> init:a ->
Lemma
(let (c0, res0) = Loops.repeat_gen (n / 4) (generate_elems4_a t a max) (generate_elems4_f max f) (init, Seq.empty) in
let (c1, res1) = Loop... | [] | Hacl.Spec.Lib.lemma_generate_elems_unroll4_loop | {
"file_name": "code/bignum/Hacl.Spec.Lib.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
max: Prims.nat ->
n: Prims.nat{n <= max /\ n % 4 = 0} ->
f: (i: Prims.nat{i < max} -> _: a -> a * t) ->
init: a
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeat_gen (n / 4)
(Hacl.Spec.Lib.generate_elems4_a t a max)
(Hacl.Spec.Lib.gener... | {
"end_col": 92,
"end_line": 153,
"start_col": 58,
"start_line": 125
} |
Prims.Tot | val kind_unit:parser_kind false WeakKindStrongPrefix | [
{
"abbrev": true,
"full_module": "LowParse.Spec.Combinators",
"short_module": "LPC"
},
{
"abbrev": true,
"full_module": "LowParse.Spec.Base",
"short_module": "LP"
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"f... | false | let kind_unit
: parser_kind false WeakKindStrongPrefix
= ret_kind | val kind_unit:parser_kind false WeakKindStrongPrefix
let kind_unit:parser_kind false WeakKindStrongPrefix = | false | null | false | ret_kind | {
"checked_file": "EverParse3d.Kinds.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "EverParse3d.Kinds.fsti"
} | [
"total"
] | [
"EverParse3d.Kinds.ret_kind"
] | [] | (*
Copyright 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 agreed to... | false | false | EverParse3d.Kinds.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"max_ifuel": 2,
"no_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 kind_unit:parser_kind false WeakKindStrongPrefix | [] | EverParse3d.Kinds.kind_unit | {
"file_name": "src/3d/prelude/EverParse3d.Kinds.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | EverParse3d.Kinds.parser_kind false EverParse3d.Kinds.WeakKindStrongPrefix | {
"end_col": 10,
"end_line": 124,
"start_col": 2,
"start_line": 124
} |
Prims.Tot | val weak_kind_glb (k1 k2: weak_kind) : Tot weak_kind | [
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "P... | false | let weak_kind_glb
(k1 k2: weak_kind)
: Tot weak_kind
= if k1 = k2
then k1
else WeakKindWeak | val weak_kind_glb (k1 k2: weak_kind) : Tot weak_kind
let weak_kind_glb (k1 k2: weak_kind) : Tot weak_kind = | false | null | false | if k1 = k2 then k1 else WeakKindWeak | {
"checked_file": "EverParse3d.Kinds.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "EverParse3d.Kinds.fsti"
} | [
"total"
] | [
"EverParse3d.Kinds.weak_kind",
"Prims.op_Equality",
"Prims.bool",
"EverParse3d.Kinds.WeakKindWeak"
] | [] | (*
Copyright 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 agreed to... | false | true | EverParse3d.Kinds.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"max_ifuel": 2,
"no_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 weak_kind_glb (k1 k2: weak_kind) : Tot weak_kind | [] | EverParse3d.Kinds.weak_kind_glb | {
"file_name": "src/3d/prelude/EverParse3d.Kinds.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k1: EverParse3d.Kinds.weak_kind -> k2: EverParse3d.Kinds.weak_kind -> EverParse3d.Kinds.weak_kind | {
"end_col": 19,
"end_line": 32,
"start_col": 2,
"start_line": 30
} |
Prims.Tot | val seq_map (#a #b: Type) (f: (a -> b)) (s: seq a) : seq b | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let seq_map (#a #b:Type) (f:a -> b) (s:seq a) : seq b =
init (length s) (compose f (index s)) | val seq_map (#a #b: Type) (f: (a -> b)) (s: seq a) : seq b
let seq_map (#a #b: Type) (f: (a -> b)) (s: seq a) : seq b = | false | null | false | init (length s) (compose f (index s)) | {
"checked_file": "Vale.Lib.Seqs_s.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Lib.Seqs_s.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"FStar.Seq.Base.length",
"Vale.Lib.Seqs_s.compose",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.index"
] | [] | module Vale.Lib.Seqs_s
open FStar.Mul
open FStar.Seq
let compose (f:'b -> 'c) (g:'a -> 'b) : 'a -> 'c = fun x -> f (g x) | false | false | Vale.Lib.Seqs_s.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 seq_map (#a #b: Type) (f: (a -> b)) (s: seq a) : seq b | [] | Vale.Lib.Seqs_s.seq_map | {
"file_name": "vale/specs/defs/Vale.Lib.Seqs_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: a -> b) -> s: FStar.Seq.Base.seq a -> FStar.Seq.Base.seq b | {
"end_col": 39,
"end_line": 8,
"start_col": 2,
"start_line": 8
} |
Prims.Tot | val compose: f: ('b -> 'c) -> g: ('a -> 'b) -> 'a -> 'c | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let compose (f:'b -> 'c) (g:'a -> 'b) : 'a -> 'c = fun x -> f (g x) | val compose: f: ('b -> 'c) -> g: ('a -> 'b) -> 'a -> 'c
let compose (f: ('b -> 'c)) (g: ('a -> 'b)) : 'a -> 'c = | false | null | false | fun x -> f (g x) | {
"checked_file": "Vale.Lib.Seqs_s.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Lib.Seqs_s.fst"
} | [
"total"
] | [] | [] | module Vale.Lib.Seqs_s
open FStar.Mul
open FStar.Seq | false | false | Vale.Lib.Seqs_s.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 compose: f: ('b -> 'c) -> g: ('a -> 'b) -> 'a -> 'c | [] | Vale.Lib.Seqs_s.compose | {
"file_name": "vale/specs/defs/Vale.Lib.Seqs_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: 'b -> 'c) -> g: (_: 'a -> 'b) -> _: 'a -> 'c | {
"end_col": 67,
"end_line": 5,
"start_col": 51,
"start_line": 5
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let all_but_last (s:seq 'a {length s > 0}) =
slice s 0 (length s - 1) | let all_but_last (s: seq 'a {length s > 0}) = | false | null | false | slice s 0 (length s - 1) | {
"checked_file": "Vale.Lib.Seqs_s.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Lib.Seqs_s.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction"
] | [] | module Vale.Lib.Seqs_s
open FStar.Mul
open FStar.Seq
let compose (f:'b -> 'c) (g:'a -> 'b) : 'a -> 'c = fun x -> f (g x)
let seq_map (#a #b:Type) (f:a -> b) (s:seq a) : seq b =
init (length s) (compose f (index s)) | false | false | Vale.Lib.Seqs_s.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 all_but_last : s: FStar.Seq.Base.seq 'a {FStar.Seq.Base.length s > 0} -> FStar.Seq.Base.seq 'a | [] | Vale.Lib.Seqs_s.all_but_last | {
"file_name": "vale/specs/defs/Vale.Lib.Seqs_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq 'a {FStar.Seq.Base.length s > 0} -> FStar.Seq.Base.seq 'a | {
"end_col": 26,
"end_line": 11,
"start_col": 2,
"start_line": 11
} | |
Prims.Tot | val reverse_seq (#a: Type) (s: seq a) : seq a | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let reverse_seq (#a:Type) (s:seq a) : seq a =
init (length s) (fun i -> index s (length s - i - 1)) | val reverse_seq (#a: Type) (s: seq a) : seq a
let reverse_seq (#a: Type) (s: seq a) : seq a = | false | null | false | init (length s) (fun i -> index s (length s - i - 1)) | {
"checked_file": "Vale.Lib.Seqs_s.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Lib.Seqs_s.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"FStar.Seq.Base.length",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Prims.op_Subtraction"
] | [] | module Vale.Lib.Seqs_s
open FStar.Mul
open FStar.Seq
let compose (f:'b -> 'c) (g:'a -> 'b) : 'a -> 'c = fun x -> f (g x)
let seq_map (#a #b:Type) (f:a -> b) (s:seq a) : seq b =
init (length s) (compose f (index s))
let all_but_last (s:seq 'a {length s > 0}) =
slice s 0 (length s - 1) | false | false | Vale.Lib.Seqs_s.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 reverse_seq (#a: Type) (s: seq a) : seq a | [] | Vale.Lib.Seqs_s.reverse_seq | {
"file_name": "vale/specs/defs/Vale.Lib.Seqs_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq a -> FStar.Seq.Base.seq a | {
"end_col": 55,
"end_line": 14,
"start_col": 2,
"start_line": 14
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let pow2_24 = 16777216 | let pow2_24 = | false | null | false | 16777216 | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"total"
] | [] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | true | Vale.Def.Words.Seq.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 pow2_24 : Prims.int | [] | Vale.Def.Words.Seq.pow2_24 | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 29,
"end_line": 53,
"start_col": 21,
"start_line": 53
} | |
FStar.Pervasives.Lemma | val two_to_seq_to_two_LE (#a:Type) (x:seq2 a) :
Lemma (two_to_seq_LE (seq_to_two_LE x) == x)
[SMTPat (two_to_seq_LE (seq_to_two_LE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x) | val two_to_seq_to_two_LE (#a:Type) (x:seq2 a) :
Lemma (two_to_seq_LE (seq_to_two_LE x) == x)
[SMTPat (two_to_seq_LE (seq_to_two_LE x))]
let two_to_seq_to_two_LE #a x = | false | null | true | assert (equal (two_to_seq_LE (seq_to_two_LE x)) x) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words.Seq_s.seq2",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.two_to_seq_LE",
"Vale.Def.Words.Seq_s.seq_to_two_LE",
"Prims.unit"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs | false | false | Vale.Def.Words.Seq.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 two_to_seq_to_two_LE (#a:Type) (x:seq2 a) :
Lemma (two_to_seq_LE (seq_to_two_LE x) == x)
[SMTPat (two_to_seq_LE (seq_to_two_LE x))] | [] | Vale.Def.Words.Seq.two_to_seq_to_two_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words.Seq_s.seq2 a
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Words.Seq_s.two_to_seq_LE (Vale.Def.Words.Seq_s.seq_to_two_LE x) == x)
[SMTPat (Vale.Def.Words.Seq_s.two_to_seq_LE (Vale.Def.Words.Seq_s.seq_to_two_LE x))] | {
"end_col": 52,
"end_line": 13,
"start_col": 2,
"start_line": 13
} |
FStar.Pervasives.Lemma | val seq_nat8_to_seq_uint8_to_seq_nat8 (x:seq UInt8.t) :
Lemma (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x) == x)
[SMTPat (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_nat8_to_seq_uint8_to_seq_nat8 (x:seq UInt8.t) =
assert (equal (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x)) x) | val seq_nat8_to_seq_uint8_to_seq_nat8 (x:seq UInt8.t) :
Lemma (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x) == x)
[SMTPat (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x))]
let seq_nat8_to_seq_uint8_to_seq_nat8 (x: seq UInt8.t) = | false | null | true | assert (equal (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x)) x) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8",
"Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8",
"Prims.unit"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_nat8_to_seq_uint8_to_seq_nat8 (x:seq UInt8.t) :
Lemma (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x) == x)
[SMTPat (seq_nat8_to_seq_uint8 (seq_uint8_to_seq_nat8 x))] | [] | Vale.Def.Words.Seq.seq_nat8_to_seq_uint8_to_seq_nat8 | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq FStar.UInt8.t
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8 (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 x) ==
x)
[
SMTPat (Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8 (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8
... | {
"end_col": 68,
"end_line": 167,
"start_col": 2,
"start_line": 167
} |
FStar.Pervasives.Lemma | val seq_four_to_seq_LE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_four_to_seq_LE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x')
=
seq_four_to_seq_LE_injective a | val seq_four_to_seq_LE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x')
let seq_four_to_seq_LE_injective_specific (#a: eqtype) (x x': seq (four a))
: Lemma (seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x') = | false | null | true | seq_four_to_seq_LE_injective a | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Seq.seq_four_to_seq_LE_injective",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.eq2",
"Prims.l_or",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"Vale.Def.Words.Seq_s.seq_fou... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_four_to_seq_LE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x') | [] | Vale.Def.Words.Seq.seq_four_to_seq_LE_injective_specific | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) -> x': FStar.Seq.Base.seq (Vale.Def.Words_s.four a)
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_four_to_seq_LE x == Vale.Def.Words.Seq_s.seq_four_to_seq_LE x' ==>
x == x') | {
"end_col": 32,
"end_line": 196,
"start_col": 2,
"start_line": 196
} |
FStar.Pervasives.Lemma | val four_to_seq_to_four_BE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_BE (seq_to_four_BE x) == x) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_seq_to_four_BE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_BE (seq_to_four_BE x) == x)
=
assert (equal (four_to_seq_BE (seq_to_four_BE x)) x);
() | val four_to_seq_to_four_BE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_BE (seq_to_four_BE x) == x)
let four_to_seq_to_four_BE (#a: Type) (x: seq4 a) : Lemma (four_to_seq_BE (seq_to_four_BE x) == x) = | false | null | true | assert (equal (four_to_seq_BE (seq_to_four_BE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words.Seq_s.seq4",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.four_to_seq_BE",
"Vale.Def.Words.Seq_s.seq_to_four_BE",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_seq_to_four_BE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_BE (seq_to_four_BE x) == x) | [] | Vale.Def.Words.Seq.four_to_seq_to_four_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words.Seq_s.seq4 a
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Words.Seq_s.four_to_seq_BE (Vale.Def.Words.Seq_s.seq_to_four_BE x) == x) | {
"end_col": 4,
"end_line": 121,
"start_col": 2,
"start_line": 120
} |
FStar.Pervasives.Lemma | val seq_nat8_to_seq_uint8_injective (b b':seq nat8) : Lemma
(requires equal (seq_nat8_to_seq_uint8 b) (seq_nat8_to_seq_uint8 b'))
(ensures b == b') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_nat8_to_seq_uint8_injective b b' =
seq_map_injective UInt8.uint_to_t b b' | val seq_nat8_to_seq_uint8_injective (b b':seq nat8) : Lemma
(requires equal (seq_nat8_to_seq_uint8 b) (seq_nat8_to_seq_uint8 b'))
(ensures b == b')
let seq_nat8_to_seq_uint8_injective b b' = | false | null | true | seq_map_injective UInt8.uint_to_t b b' | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Vale.Lib.Seqs.seq_map_injective",
"FStar.UInt8.t",
"FStar.UInt8.uint_to_t",
"Prims.unit"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_nat8_to_seq_uint8_injective (b b':seq nat8) : Lemma
(requires equal (seq_nat8_to_seq_uint8 b) (seq_nat8_to_seq_uint8 b'))
(ensures b == b') | [] | Vale.Def.Words.Seq.seq_nat8_to_seq_uint8_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.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.Words_s.nat8 -> b': FStar.Seq.Base.seq Vale.Def.Words_s.nat8
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.equal (Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8 b)
(Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8 b')) (ensures b == b') | {
"end_col": 40,
"end_line": 173,
"start_col": 2,
"start_line": 173
} |
FStar.Pervasives.Lemma | val seq_uint8_to_seq_nat8_to_seq_uint8 (x:seq nat8) :
Lemma (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x) == x)
[SMTPat (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_uint8_to_seq_nat8_to_seq_uint8 (x:seq nat8) =
assert (equal (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x)) x) | val seq_uint8_to_seq_nat8_to_seq_uint8 (x:seq nat8) :
Lemma (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x) == x)
[SMTPat (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x))]
let seq_uint8_to_seq_nat8_to_seq_uint8 (x: seq nat8) = | false | null | true | assert (equal (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x)) x) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8",
"Prims.unit"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_uint8_to_seq_nat8_to_seq_uint8 (x:seq nat8) :
Lemma (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x) == x)
[SMTPat (seq_uint8_to_seq_nat8 (seq_nat8_to_seq_uint8 x))] | [] | Vale.Def.Words.Seq.seq_uint8_to_seq_nat8_to_seq_uint8 | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq Vale.Def.Words_s.nat8
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 (Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8 x) ==
x)
[
SMTPat (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 (Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8
... | {
"end_col": 68,
"end_line": 170,
"start_col": 2,
"start_line": 170
} |
FStar.Pervasives.Lemma | val four_to_seq_LE_injective (a:eqtype) : Lemma
(forall (x x':four a).{:pattern four_to_seq_LE x; four_to_seq_LE x'}
four_to_seq_LE x == four_to_seq_LE x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_seq_LE_injective (a:eqtype) :
Lemma (forall (x x': four a) . four_to_seq_LE x == four_to_seq_LE x' ==> x == x')
=
generic_injective_proof #(four a) #(seq4 a) (four_to_seq_LE #a) (seq_to_four_LE #a) (seq_to_four_to_seq_LE #a) | val four_to_seq_LE_injective (a:eqtype) : Lemma
(forall (x x':four a).{:pattern four_to_seq_LE x; four_to_seq_LE x'}
four_to_seq_LE x == four_to_seq_LE x' ==> x == x')
let four_to_seq_LE_injective (a: eqtype)
: Lemma (forall (x: four a) (x': four a). four_to_seq_LE x == four_to_seq_LE x' ==> x == x') = | false | null | true | generic_injective_proof #(four a)
#(seq4 a)
(four_to_seq_LE #a)
(seq_to_four_LE #a)
(seq_to_four_to_seq_LE #a) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.eqtype",
"Vale.Lib.Meta.generic_injective_proof",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Seq_s.seq4",
"Vale.Def.Words.Seq_s.four_to_seq_LE",
"Vale.Def.Words.Seq_s.seq_to_four_LE",
"Vale.Def.Words.Seq.seq_to_four_to_seq_LE",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_Forall",... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_seq_LE_injective (a:eqtype) : Lemma
(forall (x x':four a).{:pattern four_to_seq_LE x; four_to_seq_LE x'}
four_to_seq_LE x == four_to_seq_LE x' ==> x == x') | [] | Vale.Def.Words.Seq.four_to_seq_LE_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.eqtype
-> FStar.Pervasives.Lemma
(ensures
forall (x: Vale.Def.Words_s.four a) (x': Vale.Def.Words_s.four a).
{:pattern Vale.Def.Words.Seq_s.four_to_seq_LE x; Vale.Def.Words.Seq_s.four_to_seq_LE x'}
Vale.Def.Words.Seq_s.four_to_seq_LE x == Vale.Def.Words.Seq_s.four_to_seq_LE x' ==> x... | {
"end_col": 112,
"end_line": 206,
"start_col": 2,
"start_line": 206
} |
FStar.Pervasives.Lemma | val seq_four_to_seq_BE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_four_to_seq_BE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x')
=
seq_four_to_seq_BE_injective a | val seq_four_to_seq_BE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x')
let seq_four_to_seq_BE_injective_specific (#a: eqtype) (x x': seq (four a))
: Lemma (seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x') = | false | null | true | seq_four_to_seq_BE_injective a | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Seq.seq_four_to_seq_BE_injective",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.eq2",
"Prims.l_or",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"Vale.Def.Words.Seq_s.seq_fou... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_four_to_seq_BE_injective_specific (#a:eqtype) (x x':seq (four a)) :
Lemma (seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x') | [] | Vale.Def.Words.Seq.seq_four_to_seq_BE_injective_specific | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) -> x': FStar.Seq.Base.seq (Vale.Def.Words_s.four a)
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_four_to_seq_BE x == Vale.Def.Words.Seq_s.seq_four_to_seq_BE x' ==>
x == x') | {
"end_col": 32,
"end_line": 201,
"start_col": 2,
"start_line": 201
} |
FStar.Pervasives.Lemma | val seq_four_to_seq_BE_injective (a:eqtype) : Lemma
(forall (x x':seq (four a)).{:pattern seq_four_to_seq_BE x; seq_four_to_seq_BE x'}
seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_four_to_seq_BE_injective (a:eqtype) :
Lemma (forall (x x': seq (four a)). seq_four_to_seq_BE #a x == seq_four_to_seq_BE #a x' ==> x == x')
=
let seq_four_to_seq_BE_stronger (#b:Type) (x:seq (four b)) : (s:seq b{length s % 4 == 0}) =
seq_four_to_seq_BE x
in
generic_injective_proof (seq_four_to_seq_... | val seq_four_to_seq_BE_injective (a:eqtype) : Lemma
(forall (x x':seq (four a)).{:pattern seq_four_to_seq_BE x; seq_four_to_seq_BE x'}
seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x')
let seq_four_to_seq_BE_injective (a: eqtype)
: Lemma
(forall (x: seq (four a)) (x': seq (four a)).
seq_f... | false | null | true | let seq_four_to_seq_BE_stronger (#b: Type) (x: seq (four b)) : (s: seq b {length s % 4 == 0}) =
seq_four_to_seq_BE x
in
generic_injective_proof (seq_four_to_seq_BE_stronger)
(seq_to_seq_four_BE #a)
(seq_to_seq_four_to_seq_BE #a);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.eqtype",
"Prims.unit",
"Vale.Lib.Meta.generic_injective_proof",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Vale.Def.Words.Seq_s.seq_to_seq_four_BE",
"Vale.Def.Words.Seq.seq_to_seq_four_to_seq_BE",
"Vale.Def.Word... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_four_to_seq_BE_injective (a:eqtype) : Lemma
(forall (x x':seq (four a)).{:pattern seq_four_to_seq_BE x; seq_four_to_seq_BE x'}
seq_four_to_seq_BE x == seq_four_to_seq_BE x' ==> x == x') | [] | Vale.Def.Words.Seq.seq_four_to_seq_BE_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.eqtype
-> FStar.Pervasives.Lemma
(ensures
forall (x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a))
(x': FStar.Seq.Base.seq (Vale.Def.Words_s.four a)).
{:pattern
Vale.Def.Words.Seq_s.seq_four_to_seq_BE x; Vale.Def.Words.Seq_s.seq_four_to_seq_BE x'}
Vale.Def.Words.Seq_... | {
"end_col": 4,
"end_line": 191,
"start_col": 3,
"start_line": 186
} |
FStar.Pervasives.Lemma | val four_to_seq_LE_is_seq_four_to_seq_LE(#a:Type) (x:four a) :
Lemma (four_to_seq_LE x == seq_four_to_seq_LE (create 1 x)) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_seq_LE_is_seq_four_to_seq_LE(#a:Type) (x:four a) :
Lemma (four_to_seq_LE x == seq_four_to_seq_LE (create 1 x))
=
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
let s0 = four_to_seq_LE x in
let s1 = seq_four_to_seq_LE (create 1 x) in
assert (equal s0 s1);
() | val four_to_seq_LE_is_seq_four_to_seq_LE(#a:Type) (x:four a) :
Lemma (four_to_seq_LE x == seq_four_to_seq_LE (create 1 x))
let four_to_seq_LE_is_seq_four_to_seq_LE (#a: Type) (x: four a)
: Lemma (four_to_seq_LE x == seq_four_to_seq_LE (create 1 x)) = | false | null | true | reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
let s0 = four_to_seq_LE x in
let s1 = seq_four_to_seq_LE (create 1 x) in
assert (equal s0 s1);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.four",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"FStar.Seq.Base.create",
"Vale.Def.Words.Seq_s.seq_four_to_seq_LE",
"Vale.Def.Words.Seq_s.seq4",
"Vale.Def.Words.Seq_s... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_seq_LE_is_seq_four_to_seq_LE(#a:Type) (x:four a) :
Lemma (four_to_seq_LE x == seq_four_to_seq_LE (create 1 x)) | [] | Vale.Def.Words.Seq.four_to_seq_LE_is_seq_four_to_seq_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words_s.four a
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.four_to_seq_LE x ==
Vale.Def.Words.Seq_s.seq_four_to_seq_LE (FStar.Seq.Base.create 1 x)) | {
"end_col": 4,
"end_line": 135,
"start_col": 2,
"start_line": 131
} |
FStar.Pervasives.Lemma | val four_to_seq_BE_injective (a:eqtype) : Lemma
(forall (x x':four a).{:pattern four_to_seq_BE x; four_to_seq_BE x'}
four_to_seq_BE x == four_to_seq_BE x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_seq_BE_injective (a:eqtype) :
Lemma (forall (x x': four a) . four_to_seq_BE x == four_to_seq_BE x' ==> x == x')
=
generic_injective_proof #(four a) #(seq4 a) (four_to_seq_BE #a) (seq_to_four_BE #a) (seq_to_four_to_seq_BE #a) | val four_to_seq_BE_injective (a:eqtype) : Lemma
(forall (x x':four a).{:pattern four_to_seq_BE x; four_to_seq_BE x'}
four_to_seq_BE x == four_to_seq_BE x' ==> x == x')
let four_to_seq_BE_injective (a: eqtype)
: Lemma (forall (x: four a) (x': four a). four_to_seq_BE x == four_to_seq_BE x' ==> x == x') = | false | null | true | generic_injective_proof #(four a)
#(seq4 a)
(four_to_seq_BE #a)
(seq_to_four_BE #a)
(seq_to_four_to_seq_BE #a) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.eqtype",
"Vale.Lib.Meta.generic_injective_proof",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Seq_s.seq4",
"Vale.Def.Words.Seq_s.four_to_seq_BE",
"Vale.Def.Words.Seq_s.seq_to_four_BE",
"Vale.Def.Words.Seq.seq_to_four_to_seq_BE",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_Forall",... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_seq_BE_injective (a:eqtype) : Lemma
(forall (x x':four a).{:pattern four_to_seq_BE x; four_to_seq_BE x'}
four_to_seq_BE x == four_to_seq_BE x' ==> x == x') | [] | Vale.Def.Words.Seq.four_to_seq_BE_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.eqtype
-> FStar.Pervasives.Lemma
(ensures
forall (x: Vale.Def.Words_s.four a) (x': Vale.Def.Words_s.four a).
{:pattern Vale.Def.Words.Seq_s.four_to_seq_BE x; Vale.Def.Words.Seq_s.four_to_seq_BE x'}
Vale.Def.Words.Seq_s.four_to_seq_BE x == Vale.Def.Words.Seq_s.four_to_seq_BE x' ==> x... | {
"end_col": 112,
"end_line": 211,
"start_col": 2,
"start_line": 211
} |
FStar.Pervasives.Lemma | val seq_four_to_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_BE (seq_to_seq_four_BE x) == x)
[SMTPat (seq_four_to_seq_BE (seq_to_seq_four_BE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_four_to_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_BE (seq_to_seq_four_BE x) == x)
=
reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (seq_four_to_seq_BE (seq_to_seq_four_BE... | val seq_four_to_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_BE (seq_to_seq_four_BE x) == x)
[SMTPat (seq_four_to_seq_BE (seq_to_seq_four_BE x))]
let seq_four_to_seq_to_seq_four_BE (#a: Type) (x: seq a {length x % 4 == 0})
: Lemma (seq_four_to_seq_BE (seq_to_seq_four_BE x) ... | false | null | true | reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (seq_four_to_seq_BE (seq_to_seq_four_BE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"Vale.Def.Words.Seq_s.seq_to_seq_four_BE",
"FStar.Pervasives.reveal_opaque",
"Vale.Def.Words_s.four",
... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_four_to_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_BE (seq_to_seq_four_BE x) == x)
[SMTPat (seq_four_to_seq_BE (seq_to_seq_four_BE x))] | [] | Vale.Def.Words.Seq.seq_four_to_seq_to_seq_four_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq a {FStar.Seq.Base.length x % 4 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_four_to_seq_BE (Vale.Def.Words.Seq_s.seq_to_seq_four_BE x) == x)
[SMTPat (Vale.Def.Words.Seq_s.seq_four_to_seq_BE (Vale.Def.Words.Seq_s.seq_to_seq_four_BE x))] | {
"end_col": 4,
"end_line": 51,
"start_col": 2,
"start_line": 48
} |
FStar.Pervasives.Lemma | val four_to_seq_to_four_LE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_LE (seq_to_four_LE x) == x) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_seq_to_four_LE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_LE (seq_to_four_LE x) == x)
=
assert (equal (four_to_seq_LE (seq_to_four_LE x)) x);
() | val four_to_seq_to_four_LE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_LE (seq_to_four_LE x) == x)
let four_to_seq_to_four_LE (#a: Type) (x: seq4 a) : Lemma (four_to_seq_LE (seq_to_four_LE x) == x) = | false | null | true | assert (equal (four_to_seq_LE (seq_to_four_LE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words.Seq_s.seq4",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.four_to_seq_LE",
"Vale.Def.Words.Seq_s.seq_to_four_LE",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_seq_to_four_LE (#a:Type) (x:seq4 a) :
Lemma (four_to_seq_LE (seq_to_four_LE x) == x) | [] | Vale.Def.Words.Seq.four_to_seq_to_four_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words.Seq_s.seq4 a
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Words.Seq_s.four_to_seq_LE (Vale.Def.Words.Seq_s.seq_to_four_LE x) == x) | {
"end_col": 4,
"end_line": 110,
"start_col": 2,
"start_line": 109
} |
FStar.Pervasives.Lemma | val seq_four_to_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_LE (seq_to_seq_four_LE x) == x)
[SMTPat (seq_four_to_seq_LE (seq_to_seq_four_LE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_four_to_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_LE (seq_to_seq_four_LE x) == x)
=
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (seq_four_to_seq_LE (seq_to_seq_four_LE... | val seq_four_to_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_LE (seq_to_seq_four_LE x) == x)
[SMTPat (seq_four_to_seq_LE (seq_to_seq_four_LE x))]
let seq_four_to_seq_to_seq_four_LE (#a: Type) (x: seq a {length x % 4 == 0})
: Lemma (seq_four_to_seq_LE (seq_to_seq_four_LE x) ... | false | null | true | reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (seq_four_to_seq_LE (seq_to_seq_four_LE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_four_to_seq_LE",
"Vale.Def.Words.Seq_s.seq_to_seq_four_LE",
"FStar.Pervasives.reveal_opaque",
"Vale.Def.Words_s.four",
... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_four_to_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) :
Lemma (seq_four_to_seq_LE (seq_to_seq_four_LE x) == x)
[SMTPat (seq_four_to_seq_LE (seq_to_seq_four_LE x))] | [] | Vale.Def.Words.Seq.seq_four_to_seq_to_seq_four_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq a {FStar.Seq.Base.length x % 4 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_four_to_seq_LE (Vale.Def.Words.Seq_s.seq_to_seq_four_LE x) == x)
[SMTPat (Vale.Def.Words.Seq_s.seq_four_to_seq_LE (Vale.Def.Words.Seq_s.seq_to_seq_four_LE x))] | {
"end_col": 4,
"end_line": 43,
"start_col": 2,
"start_line": 40
} |
FStar.Pervasives.Lemma | val seq_four_to_seq_LE_injective (a:eqtype) : Lemma
(forall (x x':seq (four a)).{:pattern seq_four_to_seq_LE x; seq_four_to_seq_LE x'}
seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_four_to_seq_LE_injective (a:eqtype) :
Lemma (forall (x x': seq (four a)). seq_four_to_seq_LE #a x == seq_four_to_seq_LE #a x' ==> x == x')
=
let seq_four_to_seq_LE_stronger (#b:Type) (x:seq (four b)) : (s:seq b{length s % 4 == 0}) =
seq_four_to_seq_LE x
in
generic_injective_proof (seq_four_to_seq_... | val seq_four_to_seq_LE_injective (a:eqtype) : Lemma
(forall (x x':seq (four a)).{:pattern seq_four_to_seq_LE x; seq_four_to_seq_LE x'}
seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x')
let seq_four_to_seq_LE_injective (a: eqtype)
: Lemma
(forall (x: seq (four a)) (x': seq (four a)).
seq_f... | false | null | true | let seq_four_to_seq_LE_stronger (#b: Type) (x: seq (four b)) : (s: seq b {length s % 4 == 0}) =
seq_four_to_seq_LE x
in
generic_injective_proof (seq_four_to_seq_LE_stronger)
(seq_to_seq_four_LE #a)
(seq_to_seq_four_to_seq_LE #a);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.eqtype",
"Prims.unit",
"Vale.Lib.Meta.generic_injective_proof",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Vale.Def.Words.Seq_s.seq_to_seq_four_LE",
"Vale.Def.Words.Seq.seq_to_seq_four_to_seq_LE",
"Vale.Def.Word... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_four_to_seq_LE_injective (a:eqtype) : Lemma
(forall (x x':seq (four a)).{:pattern seq_four_to_seq_LE x; seq_four_to_seq_LE x'}
seq_four_to_seq_LE x == seq_four_to_seq_LE x' ==> x == x') | [] | Vale.Def.Words.Seq.seq_four_to_seq_LE_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.eqtype
-> FStar.Pervasives.Lemma
(ensures
forall (x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a))
(x': FStar.Seq.Base.seq (Vale.Def.Words_s.four a)).
{:pattern
Vale.Def.Words.Seq_s.seq_four_to_seq_LE x; Vale.Def.Words.Seq_s.seq_four_to_seq_LE x'}
Vale.Def.Words.Seq_... | {
"end_col": 4,
"end_line": 182,
"start_col": 3,
"start_line": 177
} |
FStar.Pervasives.Lemma | val four_to_seq_BE_is_seq_four_to_seq_BE (x:four nat32) :
Lemma (four_to_seq_BE x == seq_four_to_seq_BE (create 1 x)) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_seq_BE_is_seq_four_to_seq_BE (x:four nat32) :
Lemma (four_to_seq_BE x == seq_four_to_seq_BE (create 1 x))
=
reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #nat32);
let s0 = four_to_seq_BE x in
let s1 = seq_four_to_seq_BE (create 1 x) in
assert (equal s0 s1);
() | val four_to_seq_BE_is_seq_four_to_seq_BE (x:four nat32) :
Lemma (four_to_seq_BE x == seq_four_to_seq_BE (create 1 x))
let four_to_seq_BE_is_seq_four_to_seq_BE (x: four nat32)
: Lemma (four_to_seq_BE x == seq_four_to_seq_BE (create 1 x)) = | false | null | true | reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #nat32);
let s0 = four_to_seq_BE x in
let s1 = seq_four_to_seq_BE (create 1 x) in
assert (equal s0 s1);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"FStar.Seq.Base.create",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"Vale.Def.Words.Seq_s.se... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_seq_BE_is_seq_four_to_seq_BE (x:four nat32) :
Lemma (four_to_seq_BE x == seq_four_to_seq_BE (create 1 x)) | [] | Vale.Def.Words.Seq.four_to_seq_BE_is_seq_four_to_seq_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words_s.four Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.four_to_seq_BE x ==
Vale.Def.Words.Seq_s.seq_four_to_seq_BE (FStar.Seq.Base.create 1 x)) | {
"end_col": 4,
"end_line": 144,
"start_col": 2,
"start_line": 140
} |
FStar.Pervasives.Lemma | val append_distributes_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) (y:seq (four a)) :
Lemma (seq_four_to_seq_LE (x @| y) == seq_four_to_seq_LE x @| seq_four_to_seq_LE y) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let append_distributes_seq_four_to_seq_LE #a x y =
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
assert (equal (seq_four_to_seq_LE (x @| y)) (seq_four_to_seq_LE x @| seq_four_to_seq_LE y)) | val append_distributes_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) (y:seq (four a)) :
Lemma (seq_four_to_seq_LE (x @| y) == seq_four_to_seq_LE x @| seq_four_to_seq_LE y)
let append_distributes_seq_four_to_seq_LE #a x y = | false | null | true | reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
assert (equal (seq_four_to_seq_LE (x @| y)) (seq_four_to_seq_LE x @| seq_four_to_seq_LE y)) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_four_to_seq_LE",
"FStar.Seq.Base.op_At_Bar",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 append_distributes_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) (y:seq (four a)) :
Lemma (seq_four_to_seq_LE (x @| y) == seq_four_to_seq_LE x @| seq_four_to_seq_LE y) | [] | Vale.Def.Words.Seq.append_distributes_seq_four_to_seq_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) -> y: FStar.Seq.Base.seq (Vale.Def.Words_s.four a)
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_four_to_seq_LE (x @| y) ==
Vale.Def.Words.Seq_s.seq_four_to_seq_LE x @| Vale.Def.Words.Seq_s.seq_four_to_seq_LE y) | {
"end_col": 93,
"end_line": 246,
"start_col": 2,
"start_line": 245
} |
FStar.Pervasives.Lemma | val seq_nat8_to_seq_nat32_to_seq_nat8_BE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x) == x)
[SMTPat (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_nat8_to_seq_nat32_to_seq_nat8_BE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x) == x)
=
assert (equal (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x)) x);
() | val seq_nat8_to_seq_nat32_to_seq_nat8_BE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x) == x)
[SMTPat (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x))]
let seq_nat8_to_seq_nat32_to_seq_nat8_BE (x: seq nat32)
: Lemma (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x) == x... | false | null | true | assert (equal (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_BE",
"Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_nat8_to_seq_nat32_to_seq_nat8_BE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x) == x)
[SMTPat (seq_nat8_to_seq_nat32_BE (seq_nat32_to_seq_nat8_BE x))] | [] | Vale.Def.Words.Seq.seq_nat8_to_seq_nat32_to_seq_nat8_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_BE (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE
x) ==
x)
[
SMTPat (Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_BE (Vale.Def.Words.Seq_s.seq_nat3... | {
"end_col": 4,
"end_line": 156,
"start_col": 2,
"start_line": 155
} |
FStar.Pervasives.Lemma | val append_distributes_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) (y:seq (four a)) :
Lemma (seq_four_to_seq_BE (x @| y) == seq_four_to_seq_BE x @| seq_four_to_seq_BE y) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let append_distributes_seq_four_to_seq_BE #a x y =
reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
assert (equal (seq_four_to_seq_BE (x @| y)) (seq_four_to_seq_BE x @| seq_four_to_seq_BE y)) | val append_distributes_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) (y:seq (four a)) :
Lemma (seq_four_to_seq_BE (x @| y) == seq_four_to_seq_BE x @| seq_four_to_seq_BE y)
let append_distributes_seq_four_to_seq_BE #a x y = | false | null | true | reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
assert (equal (seq_four_to_seq_BE (x @| y)) (seq_four_to_seq_BE x @| seq_four_to_seq_BE y)) | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"FStar.Seq.Base.op_At_Bar",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 append_distributes_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) (y:seq (four a)) :
Lemma (seq_four_to_seq_BE (x @| y) == seq_four_to_seq_BE x @| seq_four_to_seq_BE y) | [] | Vale.Def.Words.Seq.append_distributes_seq_four_to_seq_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) -> y: FStar.Seq.Base.seq (Vale.Def.Words_s.four a)
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_four_to_seq_BE (x @| y) ==
Vale.Def.Words.Seq_s.seq_four_to_seq_BE x @| Vale.Def.Words.Seq_s.seq_four_to_seq_BE y) | {
"end_col": 93,
"end_line": 250,
"start_col": 2,
"start_line": 249
} |
FStar.Pervasives.Lemma | val four_to_nat_8_injective (_:unit) : Lemma
(forall (x x':four (natN (pow2_norm 8))).{:pattern four_to_nat 8 x; four_to_nat 8 x'}
four_to_nat 8 x == four_to_nat 8 x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_nat_8_injective () :
Lemma (forall (x x':four (natN (pow2_norm 8))) . four_to_nat 8 x == four_to_nat 8 x' ==> x == x')
=
generic_injective_proof (four_to_nat 8) (nat_to_four 8) nat_to_four_to_nat | val four_to_nat_8_injective (_:unit) : Lemma
(forall (x x':four (natN (pow2_norm 8))).{:pattern four_to_nat 8 x; four_to_nat 8 x'}
four_to_nat 8 x == four_to_nat 8 x' ==> x == x')
let four_to_nat_8_injective ()
: Lemma
(forall (x: four (natN (pow2_norm 8))) (x': four (natN (pow2_norm 8))).
four_to... | false | null | true | generic_injective_proof (four_to_nat 8) (nat_to_four 8) nat_to_four_to_nat | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"Vale.Lib.Meta.generic_injective_proof",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words.Four_s.four_to_nat",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Seq.nat_to_four_to_nat",
"Prims.l_True",
"Prims.squash",
"Prims.... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_nat_8_injective (_:unit) : Lemma
(forall (x x':four (natN (pow2_norm 8))).{:pattern four_to_nat 8 x; four_to_nat 8 x'}
four_to_nat 8 x == four_to_nat 8 x' ==> x == x') | [] | Vale.Def.Words.Seq.four_to_nat_8_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.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.four (Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 8)))
(x': Vale.Def.Words_s.four (Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 8))).
{:pattern Vale.Def.Words.Four_s.four_to_nat 8 x; Vale.Def.Words.Four_s... | {
"end_col": 76,
"end_line": 216,
"start_col": 2,
"start_line": 216
} |
FStar.Pervasives.Lemma | val seq_nat8_to_seq_nat32_to_seq_nat8_LE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x) == x)
[SMTPat (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_nat8_to_seq_nat32_to_seq_nat8_LE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x) == x)
=
assert (equal (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x)) x);
() | val seq_nat8_to_seq_nat32_to_seq_nat8_LE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x) == x)
[SMTPat (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x))]
let seq_nat8_to_seq_nat32_to_seq_nat8_LE (x: seq nat32)
: Lemma (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x) == x... | false | null | true | assert (equal (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE",
"Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_LE",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_nat8_to_seq_nat32_to_seq_nat8_LE (x:seq nat32) :
Lemma (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x) == x)
[SMTPat (seq_nat8_to_seq_nat32_LE (seq_nat32_to_seq_nat8_LE x))] | [] | Vale.Def.Words.Seq.seq_nat8_to_seq_nat32_to_seq_nat8_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_LE
x) ==
x)
[
SMTPat (Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE (Vale.Def.Words.Seq_s.seq_nat3... | {
"end_col": 4,
"end_line": 150,
"start_col": 2,
"start_line": 149
} |
FStar.Pervasives.Lemma | val seq_nat32_to_seq_nat8_to_seq_nat32_LE (x:seq nat8{length x % 4 == 0}) :
Lemma (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x) == x)
[SMTPat (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_nat32_to_seq_nat8_to_seq_nat32_LE (x:seq nat8{length x % 4 == 0}) :
Lemma (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x) == x)
=
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #nat8);
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #nat8);
assert (equal (seq_nat32_to_seq_nat... | val seq_nat32_to_seq_nat8_to_seq_nat32_LE (x:seq nat8{length x % 4 == 0}) :
Lemma (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x) == x)
[SMTPat (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x))]
let seq_nat32_to_seq_nat8_to_seq_nat32_LE (x: seq nat8 {length x % 4 == 0})
: Lemma (seq_nat32_to_seq_na... | false | null | true | reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #nat8);
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #nat8);
assert (equal (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.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",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_LE",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE",
"FStar.Pervasives.revea... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_nat32_to_seq_nat8_to_seq_nat32_LE (x:seq nat8{length x % 4 == 0}) :
Lemma (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x) == x)
[SMTPat (seq_nat32_to_seq_nat8_LE (seq_nat8_to_seq_nat32_LE x))] | [] | Vale.Def.Words.Seq.seq_nat32_to_seq_nat8_to_seq_nat32_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length x % 4 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_LE (Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE
x) ==
x)
[
SMTPat (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8... | {
"end_col": 4,
"end_line": 164,
"start_col": 2,
"start_line": 161
} |
FStar.Pervasives.Lemma | val seq_to_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_BE (seq_four_to_seq_BE x) == x)
[SMTPat (seq_to_seq_four_BE (seq_four_to_seq_BE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_to_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_BE (seq_four_to_seq_BE x) == x)
[SMTPat (seq_to_seq_four_BE (seq_four_to_seq_BE x))]
=
reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal ... | val seq_to_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_BE (seq_four_to_seq_BE x) == x)
[SMTPat (seq_to_seq_four_BE (seq_four_to_seq_BE x))]
let seq_to_seq_four_to_seq_BE (#a: Type) (x: seq (four a))
: Lemma (seq_to_seq_four_BE (seq_four_to_seq_BE x) == x)
[SMTPat (seq_to_seq_fo... | false | null | true | reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (seq_to_seq_four_BE (seq_four_to_seq_BE x)) x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words.Seq_s.seq_to_seq_four_BE",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"FStar.Pervasives.reveal_opaque",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_to_seq_four_to_seq_BE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_BE (seq_four_to_seq_BE x) == x)
[SMTPat (seq_to_seq_four_BE (seq_four_to_seq_BE x))] | [] | Vale.Def.Words.Seq.seq_to_seq_four_to_seq_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a)
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_to_seq_four_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE x) == x)
[SMTPat (Vale.Def.Words.Seq_s.seq_to_seq_four_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE x))] | {
"end_col": 4,
"end_line": 35,
"start_col": 2,
"start_line": 32
} |
FStar.Pervasives.Lemma | val nat_to_four_8_injective (_:unit) : Lemma
(forall (x x':natN (pow2_norm 32)).{:pattern nat_to_four 8 x; nat_to_four 8 x'}
nat_to_four 8 x == nat_to_four 8 x' ==> x == x') | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let nat_to_four_8_injective () :
Lemma (forall (x x':natN (pow2_norm 32)) . nat_to_four 8 x == nat_to_four 8 x' ==> x == x')
=
generic_injective_proof (nat_to_four 8) (four_to_nat 8) four_to_nat_to_four_8 | val nat_to_four_8_injective (_:unit) : Lemma
(forall (x x':natN (pow2_norm 32)).{:pattern nat_to_four 8 x; nat_to_four 8 x'}
nat_to_four 8 x == nat_to_four 8 x' ==> x == x')
let nat_to_four_8_injective ()
: Lemma
(forall (x: natN (pow2_norm 32)) (x': natN (pow2_norm 32)).
nat_to_four 8 x == nat_to... | false | null | true | generic_injective_proof (nat_to_four 8) (four_to_nat 8) four_to_nat_to_four_8 | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Prims.unit",
"Vale.Lib.Meta.generic_injective_proof",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.four_to_nat",
"Vale.Def.Words.Seq.four_to_nat_to_four_8",
"Prims.l_True",
"Prims.squash",
"Pri... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 nat_to_four_8_injective (_:unit) : Lemma
(forall (x x':natN (pow2_norm 32)).{:pattern nat_to_four 8 x; nat_to_four 8 x'}
nat_to_four 8 x == nat_to_four 8 x' ==> x == x') | [] | Vale.Def.Words.Seq.nat_to_four_8_injective | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.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.natN (Vale.Def.Words_s.pow2_norm 32))
(x': Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 32)).
{:pattern Vale.Def.Words.Four_s.nat_to_four 8 x; Vale.Def.Words.Four_s.nat_to_four 8 x'}
Vale.Def.Words.Four... | {
"end_col": 79,
"end_line": 221,
"start_col": 2,
"start_line": 221
} |
FStar.Pervasives.Lemma | val seq_to_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_LE (seq_four_to_seq_LE x) == x)
[SMTPat (seq_to_seq_four_LE (seq_four_to_seq_LE x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let seq_to_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_LE (seq_four_to_seq_LE x) == x)
[SMTPat (seq_to_seq_four_LE (seq_four_to_seq_LE x))]
=
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
let bytes = se... | val seq_to_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_LE (seq_four_to_seq_LE x) == x)
[SMTPat (seq_to_seq_four_LE (seq_four_to_seq_LE x))]
let seq_to_seq_four_to_seq_LE (#a: Type) (x: seq (four a))
: Lemma (seq_to_seq_four_LE (seq_four_to_seq_LE x) == x)
[SMTPat (seq_to_seq_fo... | false | null | true | reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
let bytes = seq_four_to_seq_LE x in
let fours = seq_to_seq_four_LE bytes in
assert (equal fours x);
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Division",
"Vale.Def.Words.Seq_s.seq_to_seq_four_LE",
"Prims.op_Multiply",
"Vale.Def.Words.Seq_s.seq_four_to_seq_LE",
"FStar.Perv... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 seq_to_seq_four_to_seq_LE (#a:Type) (x:seq (four a)) :
Lemma (seq_to_seq_four_LE (seq_four_to_seq_LE x) == x)
[SMTPat (seq_to_seq_four_LE (seq_four_to_seq_LE x))] | [] | Vale.Def.Words.Seq.seq_to_seq_four_to_seq_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq (Vale.Def.Words_s.four a)
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_to_seq_four_LE (Vale.Def.Words.Seq_s.seq_four_to_seq_LE x) == x)
[SMTPat (Vale.Def.Words.Seq_s.seq_to_seq_four_LE (Vale.Def.Words.Seq_s.seq_four_to_seq_LE x))] | {
"end_col": 4,
"end_line": 26,
"start_col": 2,
"start_line": 21
} |
FStar.Pervasives.Lemma | val append_distributes_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_BE (x @| y) == seq_to_seq_four_BE x @| seq_to_seq_four_BE y) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let append_distributes_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_BE (x @| y) == seq_to_seq_four_BE x @| seq_to_seq_four_BE y)
=
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (seq_to_seq_four_BE (x @| y)) (seq_to_... | val append_distributes_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_BE (x @| y) == seq_to_seq_four_BE x @| seq_to_seq_four_BE y)
let append_distributes_seq_to_seq_four_BE
(#a: Type)
(x: seq a {length x % 4 == 0})
(y: seq a {length y ... | false | null | true | reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (seq_to_seq_four_BE (x @| y)) (seq_to_seq_four_BE x @| seq_to_seq_four_BE y));
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Seq_s.seq_to_seq_four_BE",
"FStar.Seq.Base.op_At_Bar",
"FStar.Pervasives.reveal_opaque",
"Prims.op_Divi... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 append_distributes_seq_to_seq_four_BE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_BE (x @| y) == seq_to_seq_four_BE x @| seq_to_seq_four_BE y) | [] | Vale.Def.Words.Seq.append_distributes_seq_to_seq_four_BE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
x: FStar.Seq.Base.seq a {FStar.Seq.Base.length x % 4 == 0} ->
y: FStar.Seq.Base.seq a {FStar.Seq.Base.length y % 4 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_to_seq_four_BE (x @| y) ==
Vale.Def.Words.Seq_s.seq_to_seq_four_BE x @| Vale.Def.Words.Seq_s.seq_to_seq_four_BE ... | {
"end_col": 4,
"end_line": 242,
"start_col": 2,
"start_line": 240
} |
FStar.Pervasives.Lemma | val append_distributes_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_LE (x @| y) == seq_to_seq_four_LE x @| seq_to_seq_four_LE y) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let append_distributes_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_LE (x @| y) == seq_to_seq_four_LE x @| seq_to_seq_four_LE y)
=
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (seq_to_seq_four_LE (x @| y)) (seq_to_... | val append_distributes_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_LE (x @| y) == seq_to_seq_four_LE x @| seq_to_seq_four_LE y)
let append_distributes_seq_to_seq_four_LE
(#a: Type)
(x: seq a {length x % 4 == 0})
(y: seq a {length y ... | false | null | true | reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (seq_to_seq_four_LE (x @| y)) (seq_to_seq_four_LE x @| seq_to_seq_four_LE y));
() | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Seq_s.seq_to_seq_four_LE",
"FStar.Seq.Base.op_At_Bar",
"FStar.Pervasives.reveal_opaque",
"Prims.op_Divi... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 append_distributes_seq_to_seq_four_LE (#a:Type) (x:seq a{length x % 4 == 0}) (y:seq a{length y % 4 == 0}) :
Lemma (seq_to_seq_four_LE (x @| y) == seq_to_seq_four_LE x @| seq_to_seq_four_LE y) | [] | Vale.Def.Words.Seq.append_distributes_seq_to_seq_four_LE | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
x: FStar.Seq.Base.seq a {FStar.Seq.Base.length x % 4 == 0} ->
y: FStar.Seq.Base.seq a {FStar.Seq.Base.length y % 4 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_to_seq_four_LE (x @| y) ==
Vale.Def.Words.Seq_s.seq_to_seq_four_LE x @| Vale.Def.Words.Seq_s.seq_to_seq_four_LE ... | {
"end_col": 4,
"end_line": 235,
"start_col": 2,
"start_line": 233
} |
FStar.Pervasives.Lemma | val four_to_nat_to_four_8 (x:natN (pow2_norm 32)) :
Lemma (four_to_nat 8 (nat_to_four 8 x) == x)
[SMTPat (four_to_nat 8 (nat_to_four 8 x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let four_to_nat_to_four_8 (x:natN (pow2_norm 32)) :
Lemma (four_to_nat 8 (nat_to_four 8 x) == x)
[SMTPat (four_to_nat 8 (nat_to_four 8 x))]
=
let size = 8 in
let n1 = pow2_norm size in
let n2 = pow2_norm (2 * size) in
let n3 = pow2_norm (3 * size) in
let n4 = pow2_norm (4 * size) in
assert_norm (pow2 ... | val four_to_nat_to_four_8 (x:natN (pow2_norm 32)) :
Lemma (four_to_nat 8 (nat_to_four 8 x) == x)
[SMTPat (four_to_nat 8 (nat_to_four 8 x))]
let four_to_nat_to_four_8 (x: natN (pow2_norm 32))
: Lemma (four_to_nat 8 (nat_to_four 8 x) == x) [SMTPat (four_to_nat 8 (nat_to_four 8 x))] = | false | null | true | let size = 8 in
let n1 = pow2_norm size in
let n2 = pow2_norm (2 * size) in
let n3 = pow2_norm (3 * size) in
let n4 = pow2_norm (4 * size) in
assert_norm (pow2 8 == 256);
assert_norm (pow2 16 == 0x10000);
assert_norm (pow2 24 == 0x1000000);
assert_norm (pow2 32 == 0x100000000);
let fourX = nat_to_four 8 x in
assert_nor... | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.natN",
"Vale.Def.Words_s.pow2_norm",
"Prims.pow2",
"Prims.unit",
"Vale.Def.Words.Seq.lemma_fundamental_div_mod_4",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.nat",
"Prims.l_or",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_imp",
"Prims.op_LessThanOrE... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 four_to_nat_to_four_8 (x:natN (pow2_norm 32)) :
Lemma (four_to_nat 8 (nat_to_four 8 x) == x)
[SMTPat (four_to_nat 8 (nat_to_four 8 x))] | [] | Vale.Def.Words.Seq.four_to_nat_to_four_8 | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 32)
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Words.Four_s.four_to_nat 8 (Vale.Def.Words.Four_s.nat_to_four 8 x) == x)
[SMTPat (Vale.Def.Words.Four_s.four_to_nat 8 (Vale.Def.Words.Four_s.nat_to_four 8 x))] | {
"end_col": 4,
"end_line": 81,
"start_col": 3,
"start_line": 65
} |
FStar.Pervasives.Lemma | val nat_to_four_to_nat (x:four (natN (pow2_norm 8))) :
Lemma (nat_to_four 8 (four_to_nat 8 x) == x)
[SMTPat (nat_to_four 8 (four_to_nat 8 x))] | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let nat_to_four_to_nat (x:four (natN (pow2_norm 8))) :
Lemma (nat_to_four 8 (four_to_nat 8 x) == x)
[SMTPat (nat_to_four 8 (four_to_nat 8 x))]
=
let size = 8 in
let n1 = pow2_norm size in
let n2 = pow2_norm (2 * size) in
let n3 = pow2_norm (3 * size) in
let n4 = pow2_norm (4 * size) in
assert_norm (po... | val nat_to_four_to_nat (x:four (natN (pow2_norm 8))) :
Lemma (nat_to_four 8 (four_to_nat 8 x) == x)
[SMTPat (nat_to_four 8 (four_to_nat 8 x))]
let nat_to_four_to_nat (x: four (natN (pow2_norm 8)))
: Lemma (nat_to_four 8 (four_to_nat 8 x) == x) [SMTPat (nat_to_four 8 (four_to_nat 8 x))] = | false | null | true | let size = 8 in
let n1 = pow2_norm size in
let n2 = pow2_norm (2 * size) in
let n3 = pow2_norm (3 * size) in
let n4 = pow2_norm (4 * size) in
assert_norm (pow2 8 == 256);
assert_norm (pow2 16 == 0x10000);
assert_norm (pow2 24 == 0x1000000);
assert_norm (pow2 32 == 0x100000000);
let x' = four_to_nat 8 x in
assert_norm (... | {
"checked_file": "Vale.Def.Words.Seq.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Lib.Meta.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"prims.fst.checked"... | [
"lemma"
] | [
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Vale.Def.Words_s.pow2_norm",
"Prims.unit",
"Vale.Def.Words.Seq.lemma_fundamental_div_mod_4",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.nat",
"Prims.l_or",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_imp",
"Prims.op_... | [] | module Vale.Def.Words.Seq
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Mul
open Vale.Lib.Meta
open Vale.Lib.Seqs_s
open Vale.Lib.Seqs
let two_to_seq_to_two_LE #a x =
assert (equal (two_to_seq_LE (seq_to_two_LE x)) x)
let seq_to_two_to_seq_LE #a x = ()
let se... | false | false | Vale.Def.Words.Seq.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 nat_to_four_to_nat (x:four (natN (pow2_norm 8))) :
Lemma (nat_to_four 8 (four_to_nat 8 x) == x)
[SMTPat (nat_to_four 8 (four_to_nat 8 x))] | [] | Vale.Def.Words.Seq.nat_to_four_to_nat | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Seq.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Words_s.four (Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 8))
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Words.Four_s.nat_to_four 8 (Vale.Def.Words.Four_s.four_to_nat 8 x) == x)
[SMTPat (Vale.Def.Words.Four_s.nat_to_four 8 (Vale.Def.Words.Four_s.four_to_nat 8 x))] | {
"end_col": 4,
"end_line": 103,
"start_col": 3,
"start_line": 87
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let felem5 = uint64 & uint64 & uint64 & uint64 & uint64 | let felem5 = | false | null | false | uint64 & uint64 & uint64 & uint64 & uint64 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 felem5 : Type0 | [] | Hacl.Spec.K256.Field52.Definitions.felem5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 55,
"end_line": 21,
"start_col": 13,
"start_line": 21
} | |
Prims.Tot | val mk_nat5 (x: nat) : nat5 | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let mk_nat5 (x:nat) : nat5 = (x,x,x,x,x) | val mk_nat5 (x: nat) : nat5
let mk_nat5 (x: nat) : nat5 = | false | null | false | (x, x, x, x, x) | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.nat",
"FStar.Pervasives.Native.Mktuple5",
"Hacl.Spec.K256.Field52.Definitions.nat5"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 mk_nat5 (x: nat) : nat5 | [] | Hacl.Spec.K256.Field52.Definitions.mk_nat5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.nat -> Hacl.Spec.K256.Field52.Definitions.nat5 | {
"end_col": 40,
"end_line": 81,
"start_col": 29,
"start_line": 81
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let felem4 = uint64 & uint64 & uint64 & uint64 | let felem4 = | false | null | false | uint64 & uint64 & uint64 & uint64 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"FStar.Pervasives.Native.tuple4",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | false | true | Hacl.Spec.K256.Field52.Definitions.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 felem4 : Type0 | [] | Hacl.Spec.K256.Field52.Definitions.felem4 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 46,
"end_line": 12,
"start_col": 13,
"start_line": 12
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let scale64 = x:nat{x <= 4096} | let scale64 = | false | null | false | x: nat{x <= 4096} | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 scale64 : Type0 | [] | Hacl.Spec.K256.Field52.Definitions.scale64 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 30,
"end_line": 78,
"start_col": 14,
"start_line": 78
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let nat5 = nat & nat & nat & nat & nat | let nat5 = | false | null | false | nat & nat & nat & nat & nat | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"FStar.Pervasives.Native.tuple5",
"Prims.nat"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 nat5 : Type0 | [] | Hacl.Spec.K256.Field52.Definitions.nat5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 38,
"end_line": 80,
"start_col": 11,
"start_line": 80
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let scale64_last = x:nat{x <= 65536} | let scale64_last = | false | null | false | x: nat{x <= 65536} | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 scale64_last : Type0 | [] | Hacl.Spec.K256.Field52.Definitions.scale64_last | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 36,
"end_line": 79,
"start_col": 19,
"start_line": 79
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let scale64_5 = x:nat5{let (x0,x1,x2,x3,x4) = x in
x0 <= 4096 /\ x1 <= 4096 /\ x2 <= 4096 /\ x3 <= 4096 /\ x4 <= 65536} | let scale64_5 = | false | null | false | x:
nat5
{ let x0, x1, x2, x3, x4 = x in
x0 <= 4096 /\ x1 <= 4096 /\ x2 <= 4096 /\ x3 <= 4096 /\ x4 <= 65536 } | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.nat5",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 scale64_5 : Type0 | [] | Hacl.Spec.K256.Field52.Definitions.scale64_5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 70,
"end_line": 84,
"start_col": 16,
"start_line": 83
} | |
Prims.Tot | val max52:pos | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let max52 : pos =
assert_norm (pow2 52 - 1 > 0);
pow2 52 - 1 | val max52:pos
let max52:pos = | false | null | false | assert_norm (pow2 52 - 1 > 0);
pow2 52 - 1 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_GreaterThan"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 max52:pos | [] | Hacl.Spec.K256.Field52.Definitions.max52 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.pos | {
"end_col": 13,
"end_line": 106,
"start_col": 2,
"start_line": 105
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let felem_fits1 (x:uint64) (m:scale64) =
v x <= m * max52 | let felem_fits1 (x: uint64) (m: scale64) = | false | null | false | v x <= m * max52 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Lib.IntTypes.uint64",
"Hacl.Spec.K256.Field52.Definitions.scale64",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Definitions.max52",
"Prims.bool"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 felem_fits1 : x: Lib.IntTypes.uint64 -> m: Hacl.Spec.K256.Field52.Definitions.scale64 -> Prims.bool | [] | Hacl.Spec.K256.Field52.Definitions.felem_fits1 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.uint64 -> m: Hacl.Spec.K256.Field52.Definitions.scale64 -> Prims.bool | {
"end_col": 18,
"end_line": 115,
"start_col": 2,
"start_line": 115
} | |
Prims.Tot | val max48:pos | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let max48 : pos =
assert_norm (pow2 48 - 1 > 0);
pow2 48 - 1 | val max48:pos
let max48:pos = | false | null | false | assert_norm (pow2 48 - 1 > 0);
pow2 48 - 1 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_GreaterThan"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 max48:pos | [] | Hacl.Spec.K256.Field52.Definitions.max48 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.pos | {
"end_col": 13,
"end_line": 111,
"start_col": 2,
"start_line": 110
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192 | let as_nat4 (f: felem4) = | false | null | false | let f0, f1, f2, f3 = f in
v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.felem4",
"Lib.IntTypes.uint64",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.int"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64 | false | true | Hacl.Spec.K256.Field52.Definitions.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 as_nat4 : f: Hacl.Spec.K256.Field52.Definitions.felem4 -> Prims.int | [] | Hacl.Spec.K256.Field52.Definitions.as_nat4 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.K256.Field52.Definitions.felem4 -> Prims.int | {
"end_col": 59,
"end_line": 17,
"start_col": 24,
"start_line": 15
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let felem_fits_last1 (x:uint64) (m:scale64_last) =
v x <= m * max48 | let felem_fits_last1 (x: uint64) (m: scale64_last) = | false | null | false | v x <= m * max48 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Lib.IntTypes.uint64",
"Hacl.Spec.K256.Field52.Definitions.scale64_last",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Definitions.max48",
"Prims.bool"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 felem_fits_last1 : x: Lib.IntTypes.uint64 -> m: Hacl.Spec.K256.Field52.Definitions.scale64_last -> Prims.bool | [] | Hacl.Spec.K256.Field52.Definitions.felem_fits_last1 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.uint64 -> m: Hacl.Spec.K256.Field52.Definitions.scale64_last -> Prims.bool | {
"end_col": 18,
"end_line": 118,
"start_col": 2,
"start_line": 118
} | |
Prims.Tot | val feval5 (f: felem5) : S.felem | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let feval5 (f:felem5) : S.felem = as_nat5 f % S.prime | val feval5 (f: felem5) : S.felem
let feval5 (f: felem5) : S.felem = | false | null | false | as_nat5 f % S.prime | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Prims.op_Modulus",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Spec.K256.PointOps.felem"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 feval5 (f: felem5) : S.felem | [] | Hacl.Spec.K256.Field52.Definitions.feval5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.K256.Field52.Definitions.felem5 -> Spec.K256.PointOps.felem | {
"end_col": 53,
"end_line": 75,
"start_col": 34,
"start_line": 75
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let felem_fits5 (f:felem5) (m:scale64_5) =
let (f0,f1,f2,f3,f4) = f in
let (m0,m1,m2,m3,m4) = m in
felem_fits1 f0 m0 /\
felem_fits1 f1 m1 /\
felem_fits1 f2 m2 /\
felem_fits1 f3 m3 /\
felem_fits_last1 f4 m4 | let felem_fits5 (f: felem5) (m: scale64_5) = | false | null | false | let f0, f1, f2, f3, f4 = f in
let m0, m1, m2, m3, m4 = m in
felem_fits1 f0 m0 /\ felem_fits1 f1 m1 /\ felem_fits1 f2 m2 /\ felem_fits1 f3 m3 /\
felem_fits_last1 f4 m4 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Lib.IntTypes.uint64",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Hacl.Spec.K256.Field52.Definitions.felem_fits1",
"Hacl.Spec.K256.Field52.Definitions.felem_fits_last1",
"Prims.logical"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 felem_fits5 : f: Hacl.Spec.K256.Field52.Definitions.felem5 -> m: Hacl.Spec.K256.Field52.Definitions.scale64_5
-> Prims.logical | [] | Hacl.Spec.K256.Field52.Definitions.felem_fits5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.K256.Field52.Definitions.felem5 -> m: Hacl.Spec.K256.Field52.Definitions.scale64_5
-> Prims.logical | {
"end_col": 24,
"end_line": 127,
"start_col": 42,
"start_line": 120
} | |
Prims.Tot | val op_Plus_Star (x y: nat5) : nat5 | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let ( +* ) (x y:nat5) : nat5 =
let (x0,x1,x2,x3,x4) = x in
let (y0,y1,y2,y3,y4) = y in
(x0 + y0, x1 + y1, x2 + y2, x3 + y3, x4 + y4) | val op_Plus_Star (x y: nat5) : nat5
let op_Plus_Star (x y: nat5) : nat5 = | false | null | false | let x0, x1, x2, x3, x4 = x in
let y0, y1, y2, y3, y4 = y in
(x0 + y0, x1 + y1, x2 + y2, x3 + y3, x4 + y4) | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.nat5",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple5",
"Prims.op_Addition"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 op_Plus_Star (x y: nat5) : nat5 | [] | Hacl.Spec.K256.Field52.Definitions.op_Plus_Star | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Hacl.Spec.K256.Field52.Definitions.nat5 -> y: Hacl.Spec.K256.Field52.Definitions.nat5
-> Hacl.Spec.K256.Field52.Definitions.nat5 | {
"end_col": 47,
"end_line": 95,
"start_col": 30,
"start_line": 92
} |
Prims.Tot | val mask48:x: uint64{v x == pow2 48 - 1} | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let mask48: x:uint64{v x == pow2 48 - 1} =
assert_norm (pow2 48 - 1 = 0xffffffffffff);
u64 0xffffffffffff | val mask48:x: uint64{v x == pow2 48 - 1}
let mask48:x: uint64{v x == pow2 48 - 1} = | false | null | false | assert_norm (pow2 48 - 1 = 0xffffffffffff);
u64 0xffffffffffff | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Lib.IntTypes.u64",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.pow2"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | false | Hacl.Spec.K256.Field52.Definitions.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 mask48:x: uint64{v x == pow2 48 - 1} | [] | Hacl.Spec.K256.Field52.Definitions.mask48 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC {Lib.IntTypes.v x == Prims.pow2 48 - 1} | {
"end_col": 20,
"end_line": 41,
"start_col": 2,
"start_line": 40
} |
Prims.Tot | val mask52:x: uint64{v x == pow2 52 - 1} | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let mask52: x:uint64{v x == pow2 52 - 1} =
assert_norm (pow2 52 - 1 = 0xfffffffffffff);
u64 0xfffffffffffff | val mask52:x: uint64{v x == pow2 52 - 1}
let mask52:x: uint64{v x == pow2 52 - 1} = | false | null | false | assert_norm (pow2 52 - 1 = 0xfffffffffffff);
u64 0xfffffffffffff | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Lib.IntTypes.u64",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.pow2"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | false | Hacl.Spec.K256.Field52.Definitions.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 mask52:x: uint64{v x == pow2 52 - 1} | [] | Hacl.Spec.K256.Field52.Definitions.mask52 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC {Lib.IntTypes.v x == Prims.pow2 52 - 1} | {
"end_col": 21,
"end_line": 35,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | val pow52:(pow52:
pos{pow2 64 == 4096 * pow52 /\ pow2 128 == 16777216 * pow52 * pow52 /\ pow2 52 == pow52}) | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let pow52: (pow52:pos{pow2 64 == 4096 * pow52 /\ pow2 128 == 16777216 * pow52 * pow52 /\ pow2 52 == pow52}) =
let pow52:pos = normalize_term (pow2 52) in
assert_norm (pow52 = pow2 52);
assert_norm (pow2 64 = 4096 * pow52);
assert_norm (pow2 128 = 16777216 * pow52 * pow52);
pow52 | val pow52:(pow52:
pos{pow2 64 == 4096 * pow52 /\ pow2 128 == 16777216 * pow52 * pow52 /\ pow2 52 == pow52})
let pow52:(pow52:
pos{pow2 64 == 4096 * pow52 /\ pow2 128 == 16777216 * pow52 * pow52 /\ pow2 52 == pow52}) = | false | null | false | let pow52:pos = normalize_term (pow2 52) in
assert_norm (pow52 = pow2 52);
assert_norm (pow2 64 = 4096 * pow52);
assert_norm (pow2 128 = (16777216 * pow52) * pow52);
pow52 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.pos",
"FStar.Pervasives.normalize_term"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | false | Hacl.Spec.K256.Field52.Definitions.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 pow52:(pow52:
pos{pow2 64 == 4096 * pow52 /\ pow2 128 == 16777216 * pow52 * pow52 /\ pow2 52 == pow52}) | [] | Hacl.Spec.K256.Field52.Definitions.pow52 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pow52:
Prims.pos
{ Prims.pow2 64 == 4096 * pow52 /\ Prims.pow2 128 == (16777216 * pow52) * pow52 /\
Prims.pow2 52 == pow52 } | {
"end_col": 7,
"end_line": 29,
"start_col": 109,
"start_line": 24
} |
Prims.Tot | val pow104:(pow104: pos{pow2 104 == pow104 /\ pow104 == pow52 * pow52}) | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let pow104: (pow104:pos{pow2 104 == pow104 /\ pow104 == pow52 * pow52}) =
let pow104:pos = normalize_term (pow2 104) in
assert_norm (pow104 = pow2 104);
Math.Lemmas.pow2_plus 52 52;
pow104 | val pow104:(pow104: pos{pow2 104 == pow104 /\ pow104 == pow52 * pow52})
let pow104:(pow104: pos{pow2 104 == pow104 /\ pow104 == pow52 * pow52}) = | false | null | false | let pow104:pos = normalize_term (pow2 104) in
assert_norm (pow104 = pow2 104);
Math.Lemmas.pow2_plus 52 52;
pow104 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.pos",
"Prims.pow2",
"FStar.Pervasives.normalize_term"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | false | Hacl.Spec.K256.Field52.Definitions.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 pow104:(pow104: pos{pow2 104 == pow104 /\ pow104 == pow52 * pow52}) | [] | Hacl.Spec.K256.Field52.Definitions.pow104 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pow104:
Prims.pos
{ Prims.pow2 104 == pow104 /\
pow104 == Hacl.Spec.K256.Field52.Definitions.pow52 * Hacl.Spec.K256.Field52.Definitions.pow52 } | {
"end_col": 8,
"end_line": 49,
"start_col": 73,
"start_line": 45
} |
Prims.Tot | val as_nat5 (f: felem5) : nat | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let as_nat5 (f:felem5) : nat =
let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208 | val as_nat5 (f: felem5) : nat
let as_nat5 (f: felem5) : nat = | false | null | false | let f0, f1, f2, f3, f4 = f in
v f0 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Definitions.pow52",
"Hacl.Spec.K256.Field52.Definitions.pow104",
"Hacl.Spec.K256.Field52.Definitions.pow15... | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 as_nat5 (f: felem5) : nat | [] | Hacl.Spec.K256.Field52.Definitions.as_nat5 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.K256.Field52.Definitions.felem5 -> Prims.nat | {
"end_col": 69,
"end_line": 72,
"start_col": 30,
"start_line": 70
} |
Prims.Tot | val op_Star_Star (x y: nat5) : nat5 | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let ( ** ) (x y:nat5) : nat5 =
let (x0,x1,x2,x3,x4) = x in
let (y0,y1,y2,y3,y4) = y in
(x0 * y0, x1 * y1, x2 * y2, x3 * y3, x4 * y4) | val op_Star_Star (x y: nat5) : nat5
let op_Star_Star (x y: nat5) : nat5 = | false | null | false | let x0, x1, x2, x3, x4 = x in
let y0, y1, y2, y3, y4 = y in
(x0 * y0, x1 * y1, x2 * y2, x3 * y3, x4 * y4) | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Hacl.Spec.K256.Field52.Definitions.nat5",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple5",
"FStar.Mul.op_Star"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | true | Hacl.Spec.K256.Field52.Definitions.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 op_Star_Star (x y: nat5) : nat5 | [] | Hacl.Spec.K256.Field52.Definitions.op_Star_Star | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Hacl.Spec.K256.Field52.Definitions.nat5 -> y: Hacl.Spec.K256.Field52.Definitions.nat5
-> Hacl.Spec.K256.Field52.Definitions.nat5 | {
"end_col": 47,
"end_line": 100,
"start_col": 30,
"start_line": 97
} |
Prims.Tot | val pow156:(pow156: pos{pow2 156 == pow156 /\ pow156 == pow52 * pow52 * pow52}) | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let pow156: (pow156:pos{pow2 156 == pow156 /\ pow156 == pow52 * pow52 * pow52}) =
let pow156:pos = normalize_term (pow2 156) in
assert_norm (pow156 = pow2 156);
Math.Lemmas.pow2_plus 52 52;
Math.Lemmas.pow2_plus 104 52;
pow156 | val pow156:(pow156: pos{pow2 156 == pow156 /\ pow156 == pow52 * pow52 * pow52})
let pow156:(pow156: pos{pow2 156 == pow156 /\ pow156 == pow52 * pow52 * pow52}) = | false | null | false | let pow156:pos = normalize_term (pow2 156) in
assert_norm (pow156 = pow2 156);
Math.Lemmas.pow2_plus 52 52;
Math.Lemmas.pow2_plus 104 52;
pow156 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.pos",
"Prims.pow2",
"FStar.Pervasives.normalize_term"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | false | Hacl.Spec.K256.Field52.Definitions.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 pow156:(pow156: pos{pow2 156 == pow156 /\ pow156 == pow52 * pow52 * pow52}) | [] | Hacl.Spec.K256.Field52.Definitions.pow156 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pow156:
Prims.pos
{ Prims.pow2 156 == pow156 /\
pow156 ==
(Hacl.Spec.K256.Field52.Definitions.pow52 * Hacl.Spec.K256.Field52.Definitions.pow52) *
Hacl.Spec.K256.Field52.Definitions.pow52 } | {
"end_col": 8,
"end_line": 57,
"start_col": 81,
"start_line": 52
} |
Prims.Tot | val pow208:(pow208: pos{pow2 208 == pow208 /\ pow208 == pow52 * pow52 * pow52 * pow52}) | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K... | false | let pow208: (pow208:pos{pow2 208 == pow208 /\ pow208 == pow52 * pow52 * pow52 * pow52}) =
let pow208:pos = normalize_term (pow2 208) in
assert_norm (pow208 = pow2 208);
Math.Lemmas.pow2_plus 52 52;
Math.Lemmas.pow2_plus 104 52;
Math.Lemmas.pow2_plus 156 52;
pow208 | val pow208:(pow208: pos{pow2 208 == pow208 /\ pow208 == pow52 * pow52 * pow52 * pow52})
let pow208:(pow208: pos{pow2 208 == pow208 /\ pow208 == pow52 * pow52 * pow52 * pow52}) = | false | null | false | let pow208:pos = normalize_term (pow2 208) in
assert_norm (pow208 = pow2 208);
Math.Lemmas.pow2_plus 52 52;
Math.Lemmas.pow2_plus 104 52;
Math.Lemmas.pow2_plus 156 52;
pow208 | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked... | [
"total"
] | [
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.pos",
"Prims.pow2",
"FStar.Pervasives.normalize_term"
] | [] | module Hacl.Spec.K256.Field52.Definitions
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let felem4 = uint64 & uint64 & uint64 & uint64
noextract
let as_nat4 (f:felem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + ... | false | false | Hacl.Spec.K256.Field52.Definitions.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 pow208:(pow208: pos{pow2 208 == pow208 /\ pow208 == pow52 * pow52 * pow52 * pow52}) | [] | Hacl.Spec.K256.Field52.Definitions.pow208 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pow208:
Prims.pos
{ Prims.pow2 208 == pow208 /\
pow208 ==
((Hacl.Spec.K256.Field52.Definitions.pow52 * Hacl.Spec.K256.Field52.Definitions.pow52) *
Hacl.Spec.K256.Field52.Definitions.pow52) *
Hacl.Spec.K256.Field52.Definitions.pow52 } | {
"end_col": 8,
"end_line": 66,
"start_col": 89,
"start_line": 60
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"... | false | let legacy_alg = a:hash_alg { a == MD5 \/ a == SHA1 } | let legacy_alg = | false | null | false | a: hash_alg{a == MD5 \/ a == SHA1} | {
"checked_file": "Hacl.Hash.MD.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Hacl.Hash.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Hash.MD.fsti"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.l_or",
"Prims.eq2",
"Spec.Hash.Definitions.MD5",
"Spec.Hash.Definitions.SHA1"
] | [] | module Hacl.Hash.MD
open Hacl.Hash.Definitions
open Spec.Hash.Definitions
module U32 = FStar.UInt32 | false | true | Hacl.Hash.MD.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 legacy_alg : Type0 | [] | Hacl.Hash.MD.legacy_alg | {
"file_name": "code/hash/Hacl.Hash.MD.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 53,
"end_line": 8,
"start_col": 17,
"start_line": 8
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"a... | false | let u51 = n:nat{n < 0x8000000000000} | let u51 = | false | null | false | n: nat{n < 0x8000000000000} | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan"
] | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | true | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 u51 : Type0 | [] | Hacl.Impl.Ed25519.PointEqual.u51 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 36,
"end_line": 52,
"start_col": 10,
"start_line": 52
} | |
FStar.HyperStack.ST.Stack | val gte_q:
s:lbuffer uint64 5ul ->
Stack bool
(requires fun h -> live h s /\
F56.qelem_fits h s (1, 1, 1, 1, 1)
)
(ensures fun h0 b h1 -> h0 == h1 /\
(b <==> F56.as_nat h0 s >= Spec.Ed25519.q)
) | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"a... | false | let gte_q s =
let h0 = ST.get() in
let s0 = s.(0ul) in
let s1 = s.(1ul) in
let s2 = s.(2ul) in
let s3 = s.(3ul) in
let s4 = s.(4ul) in
assert_norm (Spec.Ed25519.q == 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed);
let open FStar.UInt64 in
let open Lib.RawIntTypes in
if u64_to_UI... | val gte_q:
s:lbuffer uint64 5ul ->
Stack bool
(requires fun h -> live h s /\
F56.qelem_fits h s (1, 1, 1, 1, 1)
)
(ensures fun h0 b h1 -> h0 == h1 /\
(b <==> F56.as_nat h0 s >= Spec.Ed25519.q)
)
let gte_q s = | true | null | false | let h0 = ST.get () in
let s0 = s.(0ul) in
let s1 = s.(1ul) in
let s2 = s.(2ul) in
let s3 = s.(3ul) in
let s4 = s.(4ul) in
assert_norm (Spec.Ed25519.q == 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed);
let open FStar.UInt64 in
let open Lib.RawIntTypes in
if u64_to_UInt64 s4 >^ 0x00000010000000uL
the... | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"FStar.UInt64.op_Greater_Hat",
"Lib.RawIntTypes.u64_to_UInt64",
"FStar.UInt64.__uint_to_t",
"Prims.bool",
"FStar.UInt64.op_Less_Hat",
"FStar.UInt64.op_Greater_Equals_Hat",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Pr... | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | false | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 gte_q:
s:lbuffer uint64 5ul ->
Stack bool
(requires fun h -> live h s /\
F56.qelem_fits h s (1, 1, 1, 1, 1)
)
(ensures fun h0 b h1 -> h0 == h1 /\
(b <==> F56.as_nat h0 s >= Spec.Ed25519.q)
) | [] | Hacl.Impl.Ed25519.PointEqual.gte_q | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Lib.Buffer.lbuffer Lib.IntTypes.uint64 5ul -> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 13,
"end_line": 50,
"start_col": 13,
"start_line": 32
} |
FStar.HyperStack.ST.Stack | val eq:
a:felem
-> b:felem ->
Stack bool
(requires fun h -> live h a /\ live h b /\
F51.fevalh h a == F51.as_nat h a /\
F51.fevalh h b == F51.as_nat h b /\
F51.felem_fits h a (1, 1, 1, 1, 1) /\
F51.felem_fits h b (1, 1, 1, 1, 1)
)
(ensures fun h0 r h1 -> h0 == h1 /\
(r... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": tru... | false | let eq a b =
let a0 = a.(0ul) in
let a1 = a.(1ul) in
let a2 = a.(2ul) in
let a3 = a.(3ul) in
let a4 = a.(4ul) in
let b0 = b.(0ul) in
let b1 = b.(1ul) in
let b2 = b.(2ul) in
let b3 = b.(3ul) in
let b4 = b.(4ul) in
assert_norm(pow2 51 = 0x8000000000000);
assert_norm(pow2 102 = 0x400000000000000000... | val eq:
a:felem
-> b:felem ->
Stack bool
(requires fun h -> live h a /\ live h b /\
F51.fevalh h a == F51.as_nat h a /\
F51.fevalh h b == F51.as_nat h b /\
F51.felem_fits h a (1, 1, 1, 1, 1) /\
F51.felem_fits h b (1, 1, 1, 1, 1)
)
(ensures fun h0 r h1 -> h0 == h1 /\
(r... | true | null | false | let a0 = a.(0ul) in
let a1 = a.(1ul) in
let a2 = a.(2ul) in
let a3 = a.(3ul) in
let a4 = a.(4ul) in
let b0 = b.(0ul) in
let b1 = b.(1ul) in
let b2 = b.(2ul) in
let b3 = b.(3ul) in
let b4 = b.(4ul) in
assert_norm (pow2 51 = 0x8000000000000);
assert_norm (pow2 102 = 0x40000000000000000000000000);
assert_norm (pow2 153 = ... | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [] | [
"Hacl.Bignum25519.felem",
"Prims.op_AmpAmp",
"FStar.UInt64.op_Equals_Hat",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.unit",
"Hacl.Impl.Ed25519.PointEqual.lemma_equality1",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.bool",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.... | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | false | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 eq:
a:felem
-> b:felem ->
Stack bool
(requires fun h -> live h a /\ live h b /\
F51.fevalh h a == F51.as_nat h a /\
F51.fevalh h b == F51.as_nat h b /\
F51.felem_fits h a (1, 1, 1, 1, 1) /\
F51.felem_fits h b (1, 1, 1, 1, 1)
)
(ensures fun h0 r h1 -> h0 == h1 /\
(r... | [] | Hacl.Impl.Ed25519.PointEqual.eq | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Bignum25519.felem -> b: Hacl.Bignum25519.felem -> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 40,
"end_line": 216,
"start_col": 12,
"start_line": 192
} |
FStar.HyperStack.ST.Stack | val point_equal:
p:point
-> q:point ->
Stack bool
(requires fun h -> live h p /\ live h q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z <==> Spec.Ed25519.point_equal (F51.point_eval h0 p) (F51.point_eval h0 q))
) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": tru... | false | let point_equal p q =
push_frame();
let tmp = create 20ul (u64 0) in
let b = point_equal_1 p q tmp in
let res = if b then point_equal_2 p q tmp else false in
pop_frame();
res | val point_equal:
p:point
-> q:point ->
Stack bool
(requires fun h -> live h p /\ live h q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z <==> Spec.Ed25519.point_equal (F51.point_eval h0 p) (F51.point_eval h0 q))
)
let point_equal p q = | true | null | false | push_frame ();
let tmp = create 20ul (u64 0) in
let b = point_equal_1 p q tmp in
let res = if b then point_equal_2 p q tmp else false in
pop_frame ();
res | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [] | [
"Hacl.Bignum25519.point",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.Ed25519.PointEqual.point_equal_2",
"Hacl.Impl.Ed25519.PointEqual.point_equal_1",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt... | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | false | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 point_equal:
p:point
-> q:point ->
Stack bool
(requires fun h -> live h p /\ live h q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z <==> Spec.Ed25519.point_equal (F51.point_eval h0 p) (F51.point_eval h0 q))
) | [] | Hacl.Impl.Ed25519.PointEqual.point_equal | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Bignum25519.point -> q: Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 5,
"end_line": 296,
"start_col": 2,
"start_line": 291
} |
FStar.HyperStack.ST.Stack | val point_equal_1:
p:point
-> q:point
-> tmp:lbuffer uint64 20ul ->
Stack bool
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies (loc tmp) h0 h1 /\
(let... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": tru... | false | let point_equal_1 p q tmp =
let pxqz = sub tmp 0ul 5ul in
let qxpz = sub tmp 5ul 5ul in
let pyqz = sub tmp 10ul 5ul in
let qypz = sub tmp 15ul 5ul in
let h0 = ST.get() in
fmul pxqz (getx p) (getz q);
reduce pxqz;
fmul qxpz (getx q) (getz p);
reduce qxpz;
eq pxqz qxpz | val point_equal_1:
p:point
-> q:point
-> tmp:lbuffer uint64 20ul ->
Stack bool
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies (loc tmp) h0 h1 /\
(let... | true | null | false | let pxqz = sub tmp 0ul 5ul in
let qxpz = sub tmp 5ul 5ul in
let pyqz = sub tmp 10ul 5ul in
let qypz = sub tmp 15ul 5ul in
let h0 = ST.get () in
fmul pxqz (getx p) (getz q);
reduce pxqz;
fmul qxpz (getx q) (getz p);
reduce qxpz;
eq pxqz qxpz | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Ed25519.PointEqual.eq",
"Prims.bool",
"Prims.unit",
"Hacl.Bignum25519.reduce",
"Hacl.Bignum25519.fmul",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.getz",
"Hacl.Bignum25519.getx",
"F... | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | false | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 point_equal_1:
p:point
-> q:point
-> tmp:lbuffer uint64 20ul ->
Stack bool
(requires fun h ->
live h p /\ live h q /\ live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies (loc tmp) h0 h1 /\
(let... | [] | Hacl.Impl.Ed25519.PointEqual.point_equal_1 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
p: Hacl.Bignum25519.point ->
q: Hacl.Bignum25519.point ->
tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 20ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 14,
"end_line": 247,
"start_col": 27,
"start_line": 237
} |
FStar.HyperStack.ST.Stack | val point_equal_2:
p:point
-> q:point
-> tmp:lbuffer uint64 20ul ->
Stack bool
(requires fun h ->
live h p /\ live h q /\live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies (loc tmp) h0 h1 /\
(let ... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": tru... | false | let point_equal_2 p q tmp =
let pxqz = sub tmp 0ul 5ul in
let qxpz = sub tmp 5ul 5ul in
let pyqz = sub tmp 10ul 5ul in
let qypz = sub tmp 15ul 5ul in
fmul pyqz (gety p) (getz q);
reduce pyqz;
fmul qypz (gety q) (getz p);
reduce qypz;
eq pyqz qypz | val point_equal_2:
p:point
-> q:point
-> tmp:lbuffer uint64 20ul ->
Stack bool
(requires fun h ->
live h p /\ live h q /\live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies (loc tmp) h0 h1 /\
(let ... | true | null | false | let pxqz = sub tmp 0ul 5ul in
let qxpz = sub tmp 5ul 5ul in
let pyqz = sub tmp 10ul 5ul in
let qypz = sub tmp 15ul 5ul in
fmul pyqz (gety p) (getz q);
reduce pyqz;
fmul qypz (gety q) (getz p);
reduce qypz;
eq pyqz qypz | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Ed25519.PointEqual.eq",
"Prims.bool",
"Prims.unit",
"Hacl.Bignum25519.reduce",
"Hacl.Bignum25519.fmul",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.getz",
"Hacl.Bignum25519.gety",
"L... | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | false | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 point_equal_2:
p:point
-> q:point
-> tmp:lbuffer uint64 20ul ->
Stack bool
(requires fun h ->
live h p /\ live h q /\live h tmp /\
disjoint tmp p /\ disjoint tmp q /\
F51.point_inv_t h p /\ F51.point_inv_t h q
)
(ensures fun h0 z h1 -> modifies (loc tmp) h0 h1 /\
(let ... | [] | Hacl.Impl.Ed25519.PointEqual.point_equal_2 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
p: Hacl.Bignum25519.point ->
q: Hacl.Bignum25519.point ->
tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 20ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 14,
"end_line": 276,
"start_col": 27,
"start_line": 267
} |
FStar.Pervasives.Lemma | val lemma_equality1:
a:u51 -> b:u51 -> c:u51 -> d:u51 -> e:u51 ->
a':u51 -> b':u51 -> c':u51 -> d':u51 -> e':u51 ->
Lemma (requires a < pow2 51 /\ b < pow2 51 /\ c < pow2 51 /\ d < pow2 51 /\ e < pow2 51 /\
a' < pow2 51 /\ b' < pow2 51 /\ c' < pow2 51 /\ d' < pow2 51 /\ e' < pow2 51)
(en... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
"abbrev": tru... | false | let lemma_equality1 a b c d e a' b' c' d' e' =
assert_norm(pow2 51 = 0x8000000000000);
assert_norm(pow2 102 = 0x40000000000000000000000000);
assert_norm(pow2 153 = 0x200000000000000000000000000000000000000);
assert_norm(pow2 204 = 0x1000000000000000000000000000000000000000000000000000);
let lemma_l_imp () : L... | val lemma_equality1:
a:u51 -> b:u51 -> c:u51 -> d:u51 -> e:u51 ->
a':u51 -> b':u51 -> c':u51 -> d':u51 -> e':u51 ->
Lemma (requires a < pow2 51 /\ b < pow2 51 /\ c < pow2 51 /\ d < pow2 51 /\ e < pow2 51 /\
a' < pow2 51 /\ b' < pow2 51 /\ c' < pow2 51 /\ d' < pow2 51 /\ e' < pow2 51)
(en... | false | null | true | assert_norm (pow2 51 = 0x8000000000000);
assert_norm (pow2 102 = 0x40000000000000000000000000);
assert_norm (pow2 153 = 0x200000000000000000000000000000000000000);
assert_norm (pow2 204 = 0x1000000000000000000000000000000000000000000000000000);
let lemma_l_imp ()
: Lemma
(requires
a + pow2 51 * b + po... | {
"checked_file": "Hacl.Impl.Ed25519.PointEqual.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition... | [
"lemma"
] | [
"Hacl.Impl.Ed25519.PointEqual.u51",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.squash",
"Prims.op_Multiply",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Math.Lemmas.lemma_mod_inj... | [] | module Hacl.Impl.Ed25519.PointEqual
module ST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S51 = Hacl.Spec.Curve25519.Field51.Definition
m... | false | false | Hacl.Impl.Ed25519.PointEqual.fst | {
"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 lemma_equality1:
a:u51 -> b:u51 -> c:u51 -> d:u51 -> e:u51 ->
a':u51 -> b':u51 -> c':u51 -> d':u51 -> e':u51 ->
Lemma (requires a < pow2 51 /\ b < pow2 51 /\ c < pow2 51 /\ d < pow2 51 /\ e < pow2 51 /\
a' < pow2 51 /\ b' < pow2 51 /\ c' < pow2 51 /\ d' < pow2 51 /\ e' < pow2 51)
(en... | [] | Hacl.Impl.Ed25519.PointEqual.lemma_equality1 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointEqual.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Impl.Ed25519.PointEqual.u51 ->
b: Hacl.Impl.Ed25519.PointEqual.u51 ->
c: Hacl.Impl.Ed25519.PointEqual.u51 ->
d: Hacl.Impl.Ed25519.PointEqual.u51 ->
e: Hacl.Impl.Ed25519.PointEqual.u51 ->
a': Hacl.Impl.Ed25519.PointEqual.u51 ->
b': Hacl.Impl.Ed25519.PointEqual.u51 ->
c': Hacl.Imp... | {
"end_col": 40,
"end_line": 174,
"start_col": 2,
"start_line": 69
} |
Prims.Tot | val cs:S.ciphersuite | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module... | false | let cs:S.ciphersuite = (DH.DH_P256, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_256) | val cs:S.ciphersuite
let cs:S.ciphersuite = | false | null | false | (DH.DH_P256, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_256) | {
"checked_file": "Hacl.HPKE.P256_CP128_SHA256.fsti.checked",
"dependencies": [
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Hacl.Impl.HPKE.fsti.checked",
"FStar.Pervasives.Native.fst.ch... | [
"total"
] | [
"FStar.Pervasives.Native.Mktuple4",
"Spec.Agile.DH.algorithm",
"Spec.Agile.HPKE.hash_algorithm",
"Spec.Agile.HPKE.aead",
"Spec.Hash.Definitions.hash_alg",
"Spec.Agile.DH.DH_P256",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.HPKE.Seal",
"Spec.Agile.AEAD.CHACHA20_POLY1305"
] | [] | module Hacl.HPKE.P256_CP128_SHA256
open Hacl.Impl.HPKE
module S = Spec.Agile.HPKE
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash | false | true | Hacl.HPKE.P256_CP128_SHA256.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 cs:S.ciphersuite | [] | Hacl.HPKE.P256_CP128_SHA256.cs | {
"file_name": "code/hpke/Hacl.HPKE.P256_CP128_SHA256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.Agile.HPKE.ciphersuite | {
"end_col": 96,
"end_line": 10,
"start_col": 23,
"start_line": 10
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "LowParse",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",... | false | let norm_steps = [delta_attr [`%Norm]; iota; zeta; primops] | let norm_steps = | false | null | false | [delta_attr [`%Norm]; iota; zeta; primops] | {
"checked_file": "LowParse.Norm.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Norm.fst"
} | [
"total"
] | [
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta_attr",
"Prims.string",
"Prims.Nil",
"FStar.Pervasives.iota",
"FStar.Pervasives.zeta",
"FStar.Pervasives.primops"
] | [] | module LowParse.Norm
noeq
type norm_t : Type = | Norm | false | true | LowParse.Norm.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 norm_steps : Prims.list FStar.Pervasives.norm_step | [] | LowParse.Norm.norm_steps | {
"file_name": "src/lowparse/LowParse.Norm.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Prims.list FStar.Pervasives.norm_step | {
"end_col": 59,
"end_line": 6,
"start_col": 17,
"start_line": 6
} | |
Prims.Tot | val compute_blake2s_128:compute_st Blake2S | [
{
"abbrev": false,
"full_module": "Hacl.Hash.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HMAC",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module"... | false | let compute_blake2s_128: compute_st Blake2S =
mk_compute (D.mk_impl Blake2S Hacl.Impl.Blake2.Core.M128)
hash_blake2s_128 alloca_blake2s_128 init_blake2s_128
update_multi_blake2s_128 update_last_blake2s_128 finish_blake2s_128 | val compute_blake2s_128:compute_st Blake2S
let compute_blake2s_128:compute_st Blake2S = | false | null | false | mk_compute (D.mk_impl Blake2S Hacl.Impl.Blake2.Core.M128)
hash_blake2s_128
alloca_blake2s_128
init_blake2s_128
update_multi_blake2s_128
update_last_blake2s_128
finish_blake2s_128 | {
"checked_file": "Hacl.HMAC.Blake2s_128.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.HMAC.fsti.checked",
... | [
"total"
] | [
"Hacl.HMAC.mk_compute",
"Hacl.Hash.Definitions.mk_impl",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Hash.Blake2.hash_blake2s_128",
"Hacl.Hash.Blake2.alloca_blake2s_128",
"Hacl.Hash.Blake2.init_blake2s_128",
"Hacl.Hash.Blake2.update_multi_blake2s_128",
"Hacl.Hash.Blake2.upda... | [] | module Hacl.HMAC.Blake2s_128
module B = LowStar.Buffer
module D = Hacl.Hash.Definitions
open Spec.Agile.HMAC
open Spec.Hash.Definitions
open FStar.HyperStack.ST
open Lib.IntTypes
open EverCrypt.Helpers
open Hacl.HMAC
open Hacl.Hash.Blake2
#set-options "--z3rlimit 25 --fuel 0 --ifuel 0"
[@@ Comment "Write the HMAC... | false | true | Hacl.HMAC.Blake2s_128.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 compute_blake2s_128:compute_st Blake2S | [] | Hacl.HMAC.Blake2s_128.compute_blake2s_128 | {
"file_name": "code/hmac/Hacl.HMAC.Blake2s_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.HMAC.compute_st Spec.Hash.Definitions.Blake2S | {
"end_col": 80,
"end_line": 25,
"start_col": 2,
"start_line": 23
} |
Prims.Tot | val sel_curry (m: t) (f: flag) : flag_val_t | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let sel_curry (m:t) (f:flag) : flag_val_t = sel f m | val sel_curry (m: t) (f: flag) : flag_val_t
let sel_curry (m: t) (f: flag) : flag_val_t = | false | null | false | sel f m | {
"checked_file": "Vale.X64.Flags.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
... | [
"total"
] | [
"Vale.X64.Flags.t",
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.sel",
"Vale.X64.Flags.flag_val_t"
] | [] | module Vale.X64.Flags
open FStar.Mul
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
val t : Type0
... | false | true | Vale.X64.Flags.fsti | {
"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 sel_curry (m: t) (f: flag) : flag_val_t | [] | Vale.X64.Flags.sel_curry | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.X64.Flags.t -> f: Vale.X64.Machine_s.flag -> Vale.X64.Flags.flag_val_t | {
"end_col": 51,
"end_line": 17,
"start_col": 44,
"start_line": 17
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_mo... | false | let flag_val_t = option bool | let flag_val_t = | false | null | false | option bool | {
"checked_file": "Vale.X64.Flags.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
... | [
"total"
] | [
"FStar.Pervasives.Native.option",
"Prims.bool"
] | [] | module Vale.X64.Flags
open FStar.Mul
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16 | false | true | Vale.X64.Flags.fsti | {
"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 flag_val_t : Type0 | [] | Vale.X64.Flags.flag_val_t | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 35,
"end_line": 9,
"start_col": 24,
"start_line": 9
} | |
Prims.Tot | val to_fun (m: t) : (FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)) | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module":... | false | let to_fun (m:t) : (FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)) =
FStar.FunctionalExtensionality.on flag (sel_curry m) | val to_fun (m: t) : (FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t))
let to_fun (m: t) : (FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)) = | false | null | false | FStar.FunctionalExtensionality.on flag (sel_curry m) | {
"checked_file": "Vale.X64.Flags.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
... | [
"total"
] | [
"Vale.X64.Flags.t",
"FStar.FunctionalExtensionality.on",
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Vale.X64.Flags.sel_curry",
"FStar.FunctionalExtensionality.restricted_t"
] | [] | module Vale.X64.Flags
open FStar.Mul
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
val t : Type0
... | false | false | Vale.X64.Flags.fsti | {
"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 to_fun (m: t) : (FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)) | [] | Vale.X64.Flags.to_fun | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.X64.Flags.t
-> FStar.FunctionalExtensionality.restricted_t Vale.X64.Machine_s.flag
(fun _ -> Vale.X64.Flags.flag_val_t) | {
"end_col": 54,
"end_line": 20,
"start_col": 2,
"start_line": 20
} |
FStar.All.ML | val test_inline: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline () : FStar.All.ML unit =
test_inline_mov_input ();
test_inline_mov_add_input ();
test_inline_mul_inputs ();
test_inline_mov_mul_rax_100 ();
test_inline_mov_mul_inputs ();
// This test leads (rightfully) to a failure in the printer due to a gcc bug
// test_inline_mov_add_input_dummy_mul ();
... | val test_inline: Prims.unit -> FStar.All.ML unit
let test_inline () : FStar.All.ML unit = | true | null | false | test_inline_mov_input ();
test_inline_mov_add_input ();
test_inline_mul_inputs ();
test_inline_mov_mul_rax_100 ();
test_inline_mov_mul_inputs ();
test_inline_comment_add ();
test_inline_same_line ();
test_inline_same_line_newline ();
() | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.test_inline_same_line_newline",
"Vale.Test.TestInline.test_inline_same_line",
"Vale.Test.TestInline.test_inline_comment_add",
"Vale.Test.TestInline.test_inline_mov_mul_inputs",
"Vale.Test.TestInline.test_inline_mov_mul_rax_100",
"Vale.Test.TestInline.test_inline_mul_i... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 4,
"end_line": 160,
"start_col": 2,
"start_line": 150
} |
FStar.All.ML | val test_inline_mov_input: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_mov_input () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rRax || r = rRdx) in
let c = Block [
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15));
] in
print_function "test_inline_mov_input" (Some "result") args regs_mod c | val test_inline_mov_input: Prims.unit -> FStar.All.ML unit
let test_inline_mov_input () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rRax || r = rRdx) in
let c = Block [Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15))] in
print_function "test_inline_mov_input" (Some "result") args regs_mod c | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_mov_input: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_mov_input | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 72,
"end_line": 39,
"start_col": 50,
"start_line": 31
} |
FStar.All.ML | val print_function
(name: string)
(ret_val: option string)
(args: list (string & td & reg_64))
(regs_mod: (reg_64 -> bool))
(c: code)
: FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let print_function
(name:string)
(ret_val:option string)
(args:list (string & td & reg_64))
(regs_mod:reg_64 -> bool)
(c:code)
: FStar.All.ML unit
=
let len = List.length args in
let arg_names n = match List.Tot.nth args n with None -> "" | Some (x, _, _) -> x in
let arg_types = List.Tot.m... | val print_function
(name: string)
(ret_val: option string)
(args: list (string & td & reg_64))
(regs_mod: (reg_64 -> bool))
(c: code)
: FStar.All.ML unit
let print_function
(name: string)
(ret_val: option string)
(args: list (string & td & reg_64))
(regs_mod: (r... | true | null | false | let len = List.length args in
let arg_names n =
match List.Tot.nth args n with
| None -> ""
| Some (x, _, _) -> x
in
let arg_types = List.Tot.map (fun (_, t, _) -> t) args in
let arg_regs (n: reg_nat len) : reg_64 =
match List.Tot.nth args n with
| None -> 0
| Some (_, _, r) -> r
in
let _ = print_inline nam... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.string",
"FStar.Pervasives.Native.option",
"Prims.list",
"FStar.Pervasives.Native.tuple3",
"Vale.Interop.Base.td",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.code",
"Prims.unit",
"Prims.int",
"Vale.X64.Print_Inline_s.print_inline",
"Prims.Nil",
"Vale.Inte... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 print_function
(name: string)
(ret_val: option string)
(args: list (string & td & reg_64))
(regs_mod: (reg_64 -> bool))
(c: code)
: FStar.All.ML unit | [] | Vale.Test.TestInline.print_function | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
name: Prims.string ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
args: Prims.list ((Prims.string * Vale.Interop.Base.td) * Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
c: Vale.X64.Machine_Semantics_s.code
-> FStar.All.ML Prims.unit | {
"end_col": 4,
"end_line": 29,
"start_col": 3,
"start_line": 21
} |
FStar.All.ML | val test_inline_mul_inputs: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_mul_inputs () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rRbx);
("second_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rRax || r = rRdx) in
let c = Block [
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rRbx));
Ins (make_instr ins_IMul64 (OReg rRa... | val test_inline_mul_inputs: Prims.unit -> FStar.All.ML unit
let test_inline_mul_inputs () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rRbx); ("second_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rRax || r = rRdx) in
let c =
Block
[
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rRbx));
Ins (make_instr ins_IMul64 (OReg rRax) (OReg rR15))
]
in
print_function "test_inline_mul_inputs" (Some ... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_mul_inputs: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_mul_inputs | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 73,
"end_line": 62,
"start_col": 51,
"start_line": 52
} |
FStar.All.ML | val test_inline_mov_add_input: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_mov_add_input () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rRax || r = rRdx) in
let c = Block [
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15));
Ins (make_instr ins_Add64 (OReg rRax) (OConst 1));
] in
print_function... | val test_inline_mov_add_input: Prims.unit -> FStar.All.ML unit
let test_inline_mov_add_input () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rRax || r = rRdx) in
let c =
Block
[
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15));
Ins (make_instr ins_Add64 (OReg rRax) (OConst 1))
]
in
print_function "test_inline_mov_add_input" (Some "result") args regs_mod c | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_mov_add_input: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_mov_add_input | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 76,
"end_line": 50,
"start_col": 54,
"start_line": 41
} |
FStar.All.ML | val test_inline_same_line: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_same_line () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rR15 || r = rRax) in
let c = Block [
Ins (make_instr_annotate (ins_Space 0) (AnnotateSpace 0));
Ins (make_instr ins_Add64 (OReg rR15) (OReg rR15));
Ins (make_instr ins... | val test_inline_same_line: Prims.unit -> FStar.All.ML unit
let test_inline_same_line () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rR15 || r = rRax) in
let c =
Block
[
Ins (make_instr_annotate (ins_Space 0) (AnnotateSpace 0));
Ins (make_instr ins_Add64 (OReg rR15) (OReg rR15));
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15))
]
in
print_function "test_in... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_same_line: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_same_line | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 72,
"end_line": 130,
"start_col": 50,
"start_line": 120
} |
FStar.All.ML | val test_inline_comment_add: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_comment_add () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rR15 || r = rRax) in
let s = "This is a comment" in
let c = Block [
Ins (make_instr_annotate (ins_Comment s) (AnnotateComment s));
Ins (make_instr ins_Add64 (OReg rR15... | val test_inline_comment_add: Prims.unit -> FStar.All.ML unit
let test_inline_comment_add () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rR15 || r = rRax) in
let s = "This is a comment" in
let c =
Block
[
Ins (make_instr_annotate (ins_Comment s) (AnnotateComment s));
Ins (make_instr ins_Add64 (OReg rR15) (OReg rR15));
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_comment_add: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_comment_add | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 74,
"end_line": 118,
"start_col": 52,
"start_line": 107
} |
FStar.All.ML | val test_inline_mov_mul_inputs: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_mov_mul_inputs () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rRbx);
("second_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rRax || r = rRcx || r = rRdx) in
let c = Block [
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rRbx));
Ins (make_instr ins_... | val test_inline_mov_mul_inputs: Prims.unit -> FStar.All.ML unit
let test_inline_mov_mul_inputs () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rRbx); ("second_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rRax || r = rRcx || r = rRdx) in
let c =
Block
[
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rRbx));
Ins (make_instr ins_Mov64 (OReg rRcx) (OReg rR15));
Ins (make_instr ins_IMul64 (OReg rRax... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_mov_mul_inputs: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_mov_mul_inputs | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 77,
"end_line": 87,
"start_col": 55,
"start_line": 76
} |
FStar.All.ML | val test_inline_mov_mul_rax_100: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_mov_mul_rax_100 () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rRbx);
] in
let regs_mod r = (r = rRax || r = rRcx || r = rRdx) in
let c = Block [
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rRbx));
Ins (make_instr ins_Mov64 (OReg rRcx) (OConst 100));
Ins (... | val test_inline_mov_mul_rax_100: Prims.unit -> FStar.All.ML unit
let test_inline_mov_mul_rax_100 () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rRbx)] in
let regs_mod r = (r = rRax || r = rRcx || r = rRdx) in
let c =
Block
[
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rRbx));
Ins (make_instr ins_Mov64 (OReg rRcx) (OConst 100));
Ins (make_instr ins_IMul64 (OReg rRax) (OReg rRcx))
]
in
print_function "... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_mov_mul_rax_100: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_mov_mul_rax_100 | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 78,
"end_line": 74,
"start_col": 56,
"start_line": 64
} |
FStar.All.ML | val test_inline_same_line_newline: Prims.unit -> FStar.All.ML unit | [
{
"abbrev": false,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
... | false | let test_inline_same_line_newline () : FStar.All.ML unit =
let args = [
("first_arg", TD_Base TUInt64, rR15);
] in
let regs_mod r = (r = rR15 || r = rRax) in
let c = Block [
Ins (make_instr_annotate (ins_Space 4) (AnnotateSpace 4));
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15));
Ins (make_i... | val test_inline_same_line_newline: Prims.unit -> FStar.All.ML unit
let test_inline_same_line_newline () : FStar.All.ML unit = | true | null | false | let args = [("first_arg", TD_Base TUInt64, rR15)] in
let regs_mod r = (r = rR15 || r = rRax) in
let c =
Block
[
Ins (make_instr_annotate (ins_Space 4) (AnnotateSpace 4));
Ins (make_instr ins_Mov64 (OReg rRax) (OReg rR15));
Ins (make_instr ins_Add64 (OReg rR15) (OReg rR15));
Ins (make_instr_annotate ... | {
"checked_file": "Vale.Test.TestInline.fst.checked",
"dependencies": [
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.c... | [
"ml"
] | [
"Prims.unit",
"Vale.Test.TestInline.print_function",
"FStar.Pervasives.Native.Some",
"Prims.string",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Block",
"Prims.Cons",
"Vale... | [] | module Vale.Test.TestInline
open FStar.Mul
open FStar.IO
open Vale.Arch.HeapTypes_s
open Vale.X64.Machine_s
open Vale.X64.Instructions_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.InsLemmas
open Vale.Interop.Base
open Vale.Interop.X64
open Vale.X64.Print_Inline_s
let print_function
... | false | false | Vale.Test.TestInline.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 test_inline_same_line_newline: Prims.unit -> FStar.All.ML unit | [] | Vale.Test.TestInline.test_inline_same_line_newline | {
"file_name": "vale/code/test/Vale.Test.TestInline.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ML Prims.unit | {
"end_col": 80,
"end_line": 146,
"start_col": 58,
"start_line": 132
} |
FStar.Pervasives.Lemma | val lemma_set_to_one_reverse_equality (q0 q1: quad32)
: Lemma (requires lower3_equal q0 q1)
(ensures set_to_one_LE (reverse_bytes_quad32 q0) == set_to_one_LE (reverse_bytes_quad32 q1)) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let lemma_set_to_one_reverse_equality (q0 q1:quad32) : Lemma
(requires lower3_equal q0 q1)
(ensures set_to_one_LE (reverse_bytes_quad32 q0) == set_to_one_LE (reverse_bytes_quad32 q1))
=
reveal_reverse_bytes_quad32 q0;
reveal_reverse_bytes_quad32 q1;
() | val lemma_set_to_one_reverse_equality (q0 q1: quad32)
: Lemma (requires lower3_equal q0 q1)
(ensures set_to_one_LE (reverse_bytes_quad32 q0) == set_to_one_LE (reverse_bytes_quad32 q1))
let lemma_set_to_one_reverse_equality (q0 q1: quad32)
: Lemma (requires lower3_equal q0 q1)
(ensures set_to_one_LE ... | false | null | true | reveal_reverse_bytes_quad32 q0;
reveal_reverse_bytes_quad32 q1;
() | {
"checked_file": "Vale.AES.GCM.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fst... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Types_s.reveal_reverse_bytes_quad32",
"Prims.b2t",
"Vale.AES.GCM.lower3_equal",
"Prims.squash",
"Prims.eq2",
"Vale.AES.GCM.set_to_one_LE",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.AES.GCM
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.AES.GCM_s
open Vale.AES.AES_s
open Vale.AES.GCM_helpers
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GHash_s
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Calc
open Vale.... | false | false | Vale.AES.GCM.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_set_to_one_reverse_equality (q0 q1: quad32)
: Lemma (requires lower3_equal q0 q1)
(ensures set_to_one_LE (reverse_bytes_quad32 q0) == set_to_one_LE (reverse_bytes_quad32 q1)) | [] | Vale.AES.GCM.lemma_set_to_one_reverse_equality | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCM.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q0: Vale.Def.Types_s.quad32 -> q1: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma (requires Vale.AES.GCM.lower3_equal q0 q1)
(ensures
Vale.AES.GCM.set_to_one_LE (Vale.Def.Types_s.reverse_bytes_quad32 q0) ==
Vale.AES.GCM.set_to_one_LE (Vale.Def.Types_s.reverse_bytes_quad32 q1)) | {
"end_col": 5,
"end_line": 32,
"start_col": 3,
"start_line": 30
} |
FStar.Pervasives.Lemma | val append_distributes_le_seq_quad32_to_bytes (x y: seq quad32)
: Lemma
(le_seq_quad32_to_bytes (append x y) ==
append (le_seq_quad32_to_bytes x) (le_seq_quad32_to_bytes y)) | [
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_... | false | let append_distributes_le_seq_quad32_to_bytes (x y:seq quad32) :
Lemma (le_seq_quad32_to_bytes (append x y) == append (le_seq_quad32_to_bytes x) (le_seq_quad32_to_bytes y))
=
append_distributes_le_seq_quad32_to_bytes x y | val append_distributes_le_seq_quad32_to_bytes (x y: seq quad32)
: Lemma
(le_seq_quad32_to_bytes (append x y) ==
append (le_seq_quad32_to_bytes x) (le_seq_quad32_to_bytes y))
let append_distributes_le_seq_quad32_to_bytes (x y: seq quad32)
: Lemma
(le_seq_quad32_to_bytes (append x y) ==
append... | false | null | true | append_distributes_le_seq_quad32_to_bytes x y | {
"checked_file": "Vale.AES.GCM.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fst... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Arch.Types.append_distributes_le_seq_quad32_to_bytes",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_seq_quad32_to_bytes",
"FStar.Seq.Base.append",
"Prims.Nil",
"FStar.Pervasives.p... | [] | module Vale.AES.GCM
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.AES.GCM_s
open Vale.AES.AES_s
open Vale.AES.GCM_helpers
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GHash_s
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Calc
open Vale.... | false | false | Vale.AES.GCM.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 append_distributes_le_seq_quad32_to_bytes (x y: seq quad32)
: Lemma
(le_seq_quad32_to_bytes (append x y) ==
append (le_seq_quad32_to_bytes x) (le_seq_quad32_to_bytes y)) | [] | Vale.AES.GCM.append_distributes_le_seq_quad32_to_bytes | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCM.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> y: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_seq_quad32_to_bytes (FStar.Seq.Base.append x y) ==
FStar.Seq.Base.append (Vale.Def.Types_s.le_seq_quad32_to_bytes x)
(Vale.Def.Types_s.le_seq_qu... | {
"end_col": 47,
"end_line": 324,
"start_col": 2,
"start_line": 324
} |
FStar.Pervasives.Lemma | val pad_to_128_bits_multiple_append (x y: seq nat8)
: Lemma (requires length x % 16 == 0)
(ensures pad_to_128_bits (append x y) == append x (pad_to_128_bits y)) | [
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_... | false | let pad_to_128_bits_multiple_append (x y:seq nat8) : Lemma
(requires length x % 16 == 0)
(ensures pad_to_128_bits (append x y) == append x (pad_to_128_bits y))
=
assert (equal (pad_to_128_bits (append x y)) (append x (pad_to_128_bits y))) | val pad_to_128_bits_multiple_append (x y: seq nat8)
: Lemma (requires length x % 16 == 0)
(ensures pad_to_128_bits (append x y) == append x (pad_to_128_bits y))
let pad_to_128_bits_multiple_append (x y: seq nat8)
: Lemma (requires length x % 16 == 0)
(ensures pad_to_128_bits (append x y) == append x... | false | null | true | assert (equal (pad_to_128_bits (append x y)) (append x (pad_to_128_bits y))) | {
"checked_file": "Vale.AES.GCM.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fst... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Types_s.nat8",
"Vale.AES.GCTR_s.pad_to_128_bits",
"FStar.Seq.Base.append",
"Prims.unit",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.squash",
"Prims.Nil",
"... | [] | module Vale.AES.GCM
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.AES.GCM_s
open Vale.AES.AES_s
open Vale.AES.GCM_helpers
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GHash_s
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Calc
open Vale.... | false | false | Vale.AES.GCM.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 pad_to_128_bits_multiple_append (x y: seq nat8)
: Lemma (requires length x % 16 == 0)
(ensures pad_to_128_bits (append x y) == append x (pad_to_128_bits y)) | [] | Vale.AES.GCM.pad_to_128_bits_multiple_append | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCM.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 -> y: FStar.Seq.Base.seq Vale.Def.Words_s.nat8
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length x % 16 == 0)
(ensures
Vale.AES.GCTR_s.pad_to_128_bits (FStar.Seq.Base.append x y) ==
FStar.Seq.Base.append x (Vale.AES.GCTR_s.pad_to_128_bits y)) | {
"end_col": 78,
"end_line": 330,
"start_col": 2,
"start_line": 330
} |
FStar.Pervasives.Lemma | val lemma_le_seq_quad32_to_bytes_prefix_equality (q: quad32)
: Lemma
(slice (le_quad32_to_bytes q) 0 12 ==
slice (pad_to_128_bits (slice (le_quad32_to_bytes q) 0 12)) 0 12) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let lemma_le_seq_quad32_to_bytes_prefix_equality (q:quad32) : Lemma
(slice (le_quad32_to_bytes q) 0 12 == slice (pad_to_128_bits (slice (le_quad32_to_bytes q) 0 12)) 0 12)
=
assert (equal (slice (pad_to_128_bits (slice (le_quad32_to_bytes q) 0 12)) 0 12)
(slice (le_quad32_to_bytes q) 0 12));
() | val lemma_le_seq_quad32_to_bytes_prefix_equality (q: quad32)
: Lemma
(slice (le_quad32_to_bytes q) 0 12 ==
slice (pad_to_128_bits (slice (le_quad32_to_bytes q) 0 12)) 0 12)
let lemma_le_seq_quad32_to_bytes_prefix_equality (q: quad32)
: Lemma
(slice (le_quad32_to_bytes q) 0 12 ==
slice (pad_t... | false | null | true | assert (equal (slice (pad_to_128_bits (slice (le_quad32_to_bytes q) 0 12)) 0 12)
(slice (le_quad32_to_bytes q) 0 12));
() | {
"checked_file": "Vale.AES.GCM.fst.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fst... | [
"lemma"
] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Types_s.nat8",
"FStar.Seq.Base.slice",
"Vale.AES.GCTR_s.pad_to_128_bits",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FSta... | [] | module Vale.AES.GCM
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.AES.GCM_s
open Vale.AES.AES_s
open Vale.AES.GCM_helpers
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GHash_s
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Calc
open Vale.... | false | false | Vale.AES.GCM.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_le_seq_quad32_to_bytes_prefix_equality (q: quad32)
: Lemma
(slice (le_quad32_to_bytes q) 0 12 ==
slice (pad_to_128_bits (slice (le_quad32_to_bytes q) 0 12)) 0 12) | [] | Vale.AES.GCM.lemma_le_seq_quad32_to_bytes_prefix_equality | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCM.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
FStar.Seq.Base.slice (Vale.Def.Types_s.le_quad32_to_bytes q) 0 12 ==
FStar.Seq.Base.slice (Vale.AES.GCTR_s.pad_to_128_bits (FStar.Seq.Base.slice (Vale.Def.Types_s.le_quad32_to_bytes
q)
0
1... | {
"end_col": 4,
"end_line": 55,
"start_col": 2,
"start_line": 53
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.