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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.Lemma | val lemma_gf128_mul_rev_distribute_left (a b c:poly) : Lemma
((a +. b) *~ c == a *~ c +. b *~ c) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_gf128_mul_rev_distribute_left a b c =
let rev x = reverse x 127 in
let ra = rev a in
let rb = rev b in
let rc = rev c in
let g = gf128_modulus in
lemma_gf128_degree ();
calc (==) {
(a +. b) *~ c;
== {}
rev (rev (a +. b) *. rc %. g);
== {lemma_add_reverse a b 127}
rev ((ra +. ... | val lemma_gf128_mul_rev_distribute_left (a b c:poly) : Lemma
((a +. b) *~ c == a *~ c +. b *~ c)
let lemma_gf128_mul_rev_distribute_left a b c = | false | null | true | let rev x = reverse x 127 in
let ra = rev a in
let rb = rev b in
let rc = rev c in
let g = gf128_modulus in
lemma_gf128_degree ();
calc ( == ) {
(a +. b) *~ c;
( == ) { () }
rev (rev (a +. b) *. rc %. g);
( == ) { lemma_add_reverse a b 127 }
rev ((ra +. rb) *. rc %. g);
( == ) { lemma_mul_distribute_left ra... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.AES.GF128.op_Star_Tilde",
"Vale.Math.Poly2.op_Plus_Dot",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.op_Star_Dot",
"FStar.... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_gf128_mul_rev_distribute_left (a b c:poly) : Lemma
((a +. b) *~ c == a *~ c +. b *~ c) | [] | Vale.AES.GF128.lemma_gf128_mul_rev_distribute_left | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> c: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma (ensures (a +. b) *~ c == a *~ c +. b *~ c) | {
"end_col": 3,
"end_line": 691,
"start_col": 47,
"start_line": 670
} |
FStar.Pervasives.Lemma | val lemma_gf128_reduce_rev (a b h:poly) (n:pos) : Lemma
(requires
degree h >= 0 /\
n > 2 * degree h /\
degree (monomial n +. h) == n /\
degree a < n /\
degree b < n
)
(ensures (
let m = monomial n in
let g = m +. h in
let r x = reverse x (n - 1) in
let rr x = reverse x (2 * n -... | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_gf128_reduce_rev a b h n =
let m = monomial n in
let g = m +. h in
lemma_gf128_reduce a b g m h;
let r x = reverse x (n - 1) in
let rr x = reverse x (2 * n - 1) in
let ab = a *. b in
let d = (a *. b) /. m in
let dh = d *. h in
let rab = rr (a *. b) in
let rd = rab %. m in
let rdh = rr (r... | val lemma_gf128_reduce_rev (a b h:poly) (n:pos) : Lemma
(requires
degree h >= 0 /\
n > 2 * degree h /\
degree (monomial n +. h) == n /\
degree a < n /\
degree b < n
)
(ensures (
let m = monomial n in
let g = m +. h in
let r x = reverse x (n - 1) in
let rr x = reverse x (2 * n -... | false | null | true | let m = monomial n in
let g = m +. h in
lemma_gf128_reduce a b g m h;
let r x = reverse x (n - 1) in
let rr x = reverse x (2 * n - 1) in
let ab = a *. b in
let d = (a *. b) /. m in
let dh = d *. h in
let rab = rr (a *. b) in
let rd = rab %. m in
let rdh = rr (r rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"Prims.unit",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.op_Slash_Dot",
"Vale.Math.Poly2.Lemmas.lemma_split_define_forward",
"Vale.Math.Poly2.Lemmas.lemma_spl... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_gf128_reduce_rev (a b h:poly) (n:pos) : Lemma
(requires
degree h >= 0 /\
n > 2 * degree h /\
degree (monomial n +. h) == n /\
degree a < n /\
degree b < n
)
(ensures (
let m = monomial n in
let g = m +. h in
let r x = reverse x (n - 1) in
let rr x = reverse x (2 * n -... | [] | Vale.AES.GF128.lemma_gf128_reduce_rev | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> h: Vale.Math.Poly2_s.poly -> n: Prims.pos
-> FStar.Pervasives.Lemma
(requires
Vale.Math.Poly2_s.degree h >= 0 /\ n > 2 * Vale.Math.Poly2_s.degree h /\
Vale.Math.Poly2_s.degree (Vale.Math.Poly2_s.monomial n +. h) == n /\
Vale.Math.... | {
"end_col": 4,
"end_line": 221,
"start_col": 36,
"start_line": 186
} |
FStar.Pervasives.Lemma | val lemma_gf128_low_shift_1 (_:unit) : Lemma
(of_quad32 (Mkfour 1 0 0 0xc2000000) == reverse (shift (monomial 128 +. gf128_modulus_low_terms) (-1)) 127) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_gf128_low_shift_1 () =
let n0:nat32 = 1 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xc2000000 in
let a = reverse (shift (monomial 128 +. gf128_modulus_low_terms) (-1)) 127 in
let a0 = one in
let a3 = reverse gf128_low_shift 31 in
calc (==) {
of_quad32 (Mkfour n0 n1 n2 n3);
... | val lemma_gf128_low_shift_1 (_:unit) : Lemma
(of_quad32 (Mkfour 1 0 0 0xc2000000) == reverse (shift (monomial 128 +. gf128_modulus_low_terms) (-1)) 127)
let lemma_gf128_low_shift_1 () = | false | null | true | let n0:nat32 = 1 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xc2000000 in
let a = reverse (shift (monomial 128 +. gf128_modulus_low_terms) (- 1)) 127 in
let a0 = one in
let a3 = reverse gf128_low_shift 31 in
calc ( == ) {
of_quad32 (Mkfour n0 n1 n2 n3);
( == ) { lemma_quad32_of_nat32s n0 n1 n2 n3 }
... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Prims.unit",
"FStar.Calc.calc_finish",
"Vale.Math.Poly2_s.poly",
"Prims.eq2",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Vale.Math.Poly2.Bits_s.to_quad32",
"Vale.Math... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_gf128_low_shift_1 (_:unit) : Lemma
(of_quad32 (Mkfour 1 0 0 0xc2000000) == reverse (shift (monomial 128 +. gf128_modulus_low_terms) (-1)) 127) | [] | Vale.AES.GF128.lemma_gf128_low_shift_1 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Words_s.Mkfour 1 0 0 0xc2000000) ==
Vale.Math.Poly2_s.reverse (Vale.Math.Poly2_s.shift (Vale.Math.Poly2_s.monomial 128 +.
Vale.AES.GF128_s.gf128_modulus_low_terms)
(- 1))
127) | {
"end_col": 3,
"end_line": 644,
"start_col": 32,
"start_line": 623
} |
FStar.Pervasives.Lemma | val lemma_mul_odd_reverse_shift_right (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse (a *. h) (n + n - 1) == reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1
)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full... | false | let lemma_mul_odd_reverse_shift_right a h n =
let n1 = n - 1 in
let nn1 = n + n - 1 in
let m = monomial n in
calc (==) {
reverse (a *. h) nn1;
== {lemma_mul_reverse_shift_1 a h n1}
shift (reverse a n1 *. reverse h n1) 1;
== {lemma_shift_is_mul_left (reverse a n1 *. reverse h n1) 1}
monomial ... | val lemma_mul_odd_reverse_shift_right (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse (a *. h) (n + n - 1) == reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1
))
let lemma_mul_odd_reverse_shift_right a... | false | null | true | let n1 = n - 1 in
let nn1 = n + n - 1 in
let m = monomial n in
calc ( == ) {
reverse (a *. h) nn1;
( == ) { lemma_mul_reverse_shift_1 a h n1 }
shift (reverse a n1 *. reverse h n1) 1;
( == ) { lemma_shift_is_mul_left (reverse a n1 *. reverse h n1) 1 }
monomial 1 *. (reverse a n1 *. reverse h n1);
( == ) { le... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2_s.reverse",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.C... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_mul_odd_reverse_shift_right (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse (a *. h) (n + n - 1) == reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1
)) | [] | Vale.AES.GF128.lemma_mul_odd_reverse_shift_right | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> h: Vale.Math.Poly2_s.poly -> n: Prims.pos
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree h < n /\ Vale.Math.Poly2_s.degree a < n /\ h.[ 0 ])
(ensures
(let n1 = n - 1 in
let m = Vale.Math.Poly2_s.monomial n in
Vale.Math.Poly2_s.reverse ... | {
"end_col": 3,
"end_line": 257,
"start_col": 45,
"start_line": 239
} |
FStar.Pervasives.Lemma | val lemma_shift_key_1 (n:pos) (f h:poly) : Lemma
(requires f.[0] /\ degree f < n /\ degree h < n)
(ensures (
let g = monomial n +. f in
shift (reverse (shift_key_1 n f h) (n - 1)) 1 %. g == reverse h (n - 1) %. g
)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_shift_key_1 n f h =
let g = monomial n +. f in
lemma_monomial_add_degree n f;
let rev x = reverse x (n - 1) in
let h1 = shift h 1 in
let offset = reverse (shift g (-1)) (n - 1) in
if h1.[n] then
calc (==) {
shift (rev (mask h1 n +. offset)) 1 %. g;
== {
lemma_bitwise_all ()... | val lemma_shift_key_1 (n:pos) (f h:poly) : Lemma
(requires f.[0] /\ degree f < n /\ degree h < n)
(ensures (
let g = monomial n +. f in
shift (reverse (shift_key_1 n f h) (n - 1)) 1 %. g == reverse h (n - 1) %. g
))
let lemma_shift_key_1 n f h = | false | null | true | let g = monomial n +. f in
lemma_monomial_add_degree n f;
let rev x = reverse x (n - 1) in
let h1 = shift h 1 in
let offset = reverse (shift g (- 1)) (n - 1) in
if h1.[ n ]
then
calc ( == ) {
shift (rev (mask h1 n +. offset)) 1 %. g;
( == ) { (lemma_bitwise_all ();
lemma_equal (shift (rev (mask h1 n +. ... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Prims.pos",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2_s.op_String_Access",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.mask",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_shift_key_1 (n:pos) (f h:poly) : Lemma
(requires f.[0] /\ degree f < n /\ degree h < n)
(ensures (
let g = monomial n +. f in
shift (reverse (shift_key_1 n f h) (n - 1)) 1 %. g == reverse h (n - 1) %. g
)) | [] | Vale.AES.GF128.lemma_shift_key_1 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Prims.pos -> f: Vale.Math.Poly2_s.poly -> h: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(requires f.[ 0 ] /\ Vale.Math.Poly2_s.degree f < n /\ Vale.Math.Poly2_s.degree h < n)
(ensures
(let g = Vale.Math.Poly2_s.monomial n +. f in
Vale.Math.Poly2_s.shift (Vale.Math.Poly2_s.revers... | {
"end_col": 5,
"end_line": 744,
"start_col": 29,
"start_line": 719
} |
FStar.Pervasives.Lemma | val lemma_gf128_low_shift (_:unit) : Lemma
(shift (of_quad32 (Mkfour 0 0 0 0xc2000000)) (-64) == reverse gf128_low_shift 63) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_gf128_low_shift () =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xc2000000 in
let r3 = gf128_low_shift in
calc (==) {
shift (of_quad32 (Mkfour n0 n1 n2 n3)) (-64);
== {
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2... | val lemma_gf128_low_shift (_:unit) : Lemma
(shift (of_quad32 (Mkfour 0 0 0 0xc2000000)) (-64) == reverse gf128_low_shift 63)
let lemma_gf128_low_shift () = | false | null | true | let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xc2000000 in
let r3 = gf128_low_shift in
calc ( == ) {
shift (of_quad32 (Mkfour n0 n1 n2 n3)) (- 64);
( == ) { calc ( == ) {
Mkfour n0 n1 n2 n3;
( == ) { lemma_quad32_of_nat32s n0 n1 n2 n3 }
to_quad32 (poly128_of_nat32s n0 n1 n2... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Prims.unit",
"FStar.Calc.calc_finish",
"Vale.Math.Poly2_s.poly",
"Prims.eq2",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Prims.op_Minus",
"Vale.Math.Poly2_s.reverse",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Ni... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_gf128_low_shift (_:unit) : Lemma
(shift (of_quad32 (Mkfour 0 0 0 0xc2000000)) (-64) == reverse gf128_low_shift 63) | [] | Vale.AES.GF128.lemma_gf128_low_shift | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2_s.shift (Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Words_s.Mkfour 0
0
0
0xc2000000))
(- 64) ==
Vale.Math.Poly2_s.reverse Vale.AES.GF128.gf128_low_shift 63) | {
"end_col": 3,
"end_line": 600,
"start_col": 30,
"start_line": 571
} |
FStar.Pervasives.Lemma | val lemma_Mul128 (a b:poly) : Lemma
(requires degree a < 128 /\ degree b < 128)
(ensures (
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
a *. b == aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128
)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_Mul128 a b =
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
calc (==) {
a *. b;
== {
lemma_bitwise_all ();
lemma_equal a (aL +. shift aH 64);
lemma_equal b (bL +. shift bH 64)
}
(aL +. shift aH 64) *. (bL +. shift bH ... | val lemma_Mul128 (a b:poly) : Lemma
(requires degree a < 128 /\ degree b < 128)
(ensures (
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
a *. b == aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128
))
let lemma_Mul128 a b = | false | null | true | let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (- 64) in
let bH = shift b (- 64) in
calc ( == ) {
a *. b;
( == ) { (lemma_bitwise_all ();
lemma_equal a (aL +. shift aH 64);
lemma_equal b (bL +. shift bH 64)) }
(aL +. shift aH 64) *. (bL +. shift bH 64);
( == ) { lemma_mul_distribute_left a... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.shift",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Math.Poly2_s.monomial",
"FStar.Calc.calc... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_Mul128 (a b:poly) : Lemma
(requires degree a < 128 /\ degree b < 128)
(ensures (
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
a *. b == aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128
)) | [] | Vale.AES.GF128.lemma_Mul128 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree a < 128 /\ Vale.Math.Poly2_s.degree b < 128)
(ensures
(let aL = Vale.Math.Poly2.mask a 64 in
let bL = Vale.Math.Poly2.mask b 64 in
let aH = Vale.Math.Poly2_s.shif... | {
"end_col": 3,
"end_line": 804,
"start_col": 22,
"start_line": 773
} |
FStar.Pervasives.Lemma | val lemma_Mul128_accum (z0 z1 z2 a b:poly) : Lemma
(requires degree a < 128 /\ degree b < 128)
(ensures (
let z = z0 +. shift z1 64 +. shift z2 128 in
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
z +. a *. b == (z0 +. aL *. bL) +. shift (z1 ... | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_Mul128_accum z0 z1 z2 a b =
let z = z0 +. shift z1 64 +. shift z2 128 in
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
calc (==) {
z +. a *. b;
== {lemma_Mul128 a b}
z +. (aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) ... | val lemma_Mul128_accum (z0 z1 z2 a b:poly) : Lemma
(requires degree a < 128 /\ degree b < 128)
(ensures (
let z = z0 +. shift z1 64 +. shift z2 128 in
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
z +. a *. b == (z0 +. aL *. bL) +. shift (z1 ... | false | null | true | let z = z0 +. shift z1 64 +. shift z2 128 in
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (- 64) in
let bH = shift b (- 64) in
calc ( == ) {
z +. a *. b;
( == ) { lemma_Mul128 a b }
z +. (aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128);
( == ) { (lemma_shift_is_mul (aL *. bH... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2_s.shift",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Math.Poly2_s.monomial",
"FStar.Calc.calc... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_Mul128_accum (z0 z1 z2 a b:poly) : Lemma
(requires degree a < 128 /\ degree b < 128)
(ensures (
let z = z0 +. shift z1 64 +. shift z2 128 in
let aL = mask a 64 in
let bL = mask b 64 in
let aH = shift a (-64) in
let bH = shift b (-64) in
z +. a *. b == (z0 +. aL *. bL) +. shift (z1 ... | [] | Vale.AES.GF128.lemma_Mul128_accum | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
z0: Vale.Math.Poly2_s.poly ->
z1: Vale.Math.Poly2_s.poly ->
z2: Vale.Math.Poly2_s.poly ->
a: Vale.Math.Poly2_s.poly ->
b: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree a < 128 /\ Vale.Math.Poly2_s.degree b < 128)
(ensures
(let z = z0 +. Va... | {
"end_col": 3,
"end_line": 832,
"start_col": 37,
"start_line": 806
} |
FStar.Pervasives.Lemma | val lemma_mul_odd_reverse_shift_right_lo_shift (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse (((a *. h) %. m) *. m) (n + n - 1) == reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m
)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full... | false | let lemma_mul_odd_reverse_shift_right_lo_shift a h n =
let n1 = n - 1 in
let nn1 = n + n - 1 in
let m = monomial n in
let ah = a *. h in
calc (==) {
reverse ((ah %. m) *. m) nn1;
== {lemma_shift_is_mul (ah %. m) n; lemma_mask_is_mod ah n}
reverse (shift (mask ah n) n) nn1;
== {
lemma_bit... | val lemma_mul_odd_reverse_shift_right_lo_shift (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse (((a *. h) %. m) *. m) (n + n - 1) == reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m
))
let lemma_mul_... | false | null | true | let n1 = n - 1 in
let nn1 = n + n - 1 in
let m = monomial n in
let ah = a *. h in
calc ( == ) {
reverse ((ah %. m) *. m) nn1;
( == ) { (lemma_shift_is_mul (ah %. m) n;
lemma_mask_is_mod ah n) }
reverse (shift (mask ah n) n) nn1;
( == ) { (lemma_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) ... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2_s.reverse",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.op_Slash_Dot",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Prims.Cons",
... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_mul_odd_reverse_shift_right_lo_shift (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse (((a *. h) %. m) *. m) (n + n - 1) == reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m
)) | [] | Vale.AES.GF128.lemma_mul_odd_reverse_shift_right_lo_shift | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> h: Vale.Math.Poly2_s.poly -> n: Prims.pos
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree h < n /\ Vale.Math.Poly2_s.degree a < n /\ h.[ 0 ])
(ensures
(let n1 = n - 1 in
let m = Vale.Math.Poly2_s.monomial n in
Vale.Math.Poly2_s.reverse ... | {
"end_col": 3,
"end_line": 324,
"start_col": 54,
"start_line": 298
} |
FStar.Pervasives.Lemma | val lemma_mul_odd_reverse_shift_right_hi (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse ((a *. h) /. m) n1 == (reverse a n1 *. reverse (shift h (-1)) n1) %. m
)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full... | false | let lemma_mul_odd_reverse_shift_right_hi a h n =
let n1 = n - 1 in
let nn1 = n + n - 1 in
let m = monomial n in
let ah = a *. h in
calc (==) {
reverse (ah /. m) n1;
== {lemma_shift_is_div ah n}
reverse (shift ah (-n)) n1;
== {lemma_bitwise_all (); lemma_equal (reverse (shift ah (-n)) n1) (mask... | val lemma_mul_odd_reverse_shift_right_hi (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse ((a *. h) /. m) n1 == (reverse a n1 *. reverse (shift h (-1)) n1) %. m
))
let lemma_mul_odd_reverse_shift_right_hi a h n = | false | null | true | let n1 = n - 1 in
let nn1 = n + n - 1 in
let m = monomial n in
let ah = a *. h in
calc ( == ) {
reverse (ah /. m) n1;
( == ) { lemma_shift_is_div ah n }
reverse (shift ah (- n)) n1;
( == ) { (lemma_bitwise_all ();
lemma_equal (reverse (shift ah (- n)) n1) (mask (reverse ah nn1) n)) }
mask (reverse ah nn1)... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2_s.reverse",
"Vale.Math.Poly2.op_Slash_Dot",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Prims.Cons",
"FStar.Preorder.relation",
"P... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_mul_odd_reverse_shift_right_hi (a h:poly) (n:pos) : Lemma
(requires degree h < n /\ degree a < n /\ h.[0])
(ensures (
let n1 = n - 1 in
let m = monomial n in
reverse ((a *. h) /. m) n1 == (reverse a n1 *. reverse (shift h (-1)) n1) %. m
)) | [] | Vale.AES.GF128.lemma_mul_odd_reverse_shift_right_hi | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> h: Vale.Math.Poly2_s.poly -> n: Prims.pos
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree h < n /\ Vale.Math.Poly2_s.degree a < n /\ h.[ 0 ])
(ensures
(let n1 = n - 1 in
let m = Vale.Math.Poly2_s.monomial n in
Vale.Math.Poly2_s.reverse ... | {
"end_col": 3,
"end_line": 288,
"start_col": 48,
"start_line": 267
} |
FStar.Pervasives.Lemma | val lemma_reduce_rev (a0 a1 a2 h:poly) (n:pos) : Lemma
(requires
n == 64 /\ // verification times out unless n is known
degree a0 < n + n /\
degree a1 < n + n /\
degree a2 < n + n /\
degree (monomial (n + n) +. h) == n + n /\
degree h < n /\
h.[0]
)
(ensures (
let nn = n + n in
... | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_reduce_rev a0 a1 a2 h n =
(*
<-----256 bits------>
| a2 |
+ | a1 |
+ | a0 |
-----------------------
= | y3 | y2 | y1 | y0 |
| | y_10 |
*)
let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = reverse a (nn - 1) in
let mm ... | val lemma_reduce_rev (a0 a1 a2 h:poly) (n:pos) : Lemma
(requires
n == 64 /\ // verification times out unless n is known
degree a0 < n + n /\
degree a1 < n + n /\
degree a2 < n + n /\
degree (monomial (n + n) +. h) == n + n /\
degree h < n /\
h.[0]
)
(ensures (
let nn = n + n in
... | false | null | true | let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = reverse a (nn - 1) in
let mm = monomial nn in
let m = monomial n in
let g = mm +. h in
let c = reverse (shift h (- 1)) (n - 1) in
let y_10 = a0 +. shift (mask a1 n) n in
let y_0 = mask y_10 n in
let y_10c = swap y_10 n +. y_0 *. c in
let a = a0 +. shif... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.swap",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.mask",
"Prims.Cons",
"FStar.Preo... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reduce_rev (a0 a1 a2 h:poly) (n:pos) : Lemma
(requires
n == 64 /\ // verification times out unless n is known
degree a0 < n + n /\
degree a1 < n + n /\
degree a2 < n + n /\
degree (monomial (n + n) +. h) == n + n /\
degree h < n /\
h.[0]
)
(ensures (
let nn = n + n in
... | [] | Vale.AES.GF128.lemma_reduce_rev | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a0: Vale.Math.Poly2_s.poly ->
a1: Vale.Math.Poly2_s.poly ->
a2: Vale.Math.Poly2_s.poly ->
h: Vale.Math.Poly2_s.poly ->
n: Prims.pos
-> FStar.Pervasives.Lemma
(requires
n == 64 /\ Vale.Math.Poly2_s.degree a0 < n + n /\ Vale.Math.Poly2_s.degree a1 < n + n /\
Vale.Math.Poly2_s.... | {
"end_col": 3,
"end_line": 569,
"start_col": 35,
"start_line": 514
} |
FStar.Pervasives.Lemma | val lemma_shift_left_1 (a:poly) : Lemma
(requires degree a < 128)
(ensures to_quad32 (shift a 1) == quad32_shift_left_1 (to_quad32 a)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_reverse_define_all ();
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma... | val lemma_shift_left_1 (a:poly) : Lemma
(requires degree a < 128)
(ensures to_quad32 (shift a 1) == quad32_shift_left_1 (to_quad32 a))
let lemma_shift_left_1 a = | false | null | true | reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_reverse_define_all ();
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal (to_quad32 (shift a 1)) (quad32_s... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.unit",
"Vale.Arch.TypesNative.lemma_quad32_vec_equal",
"Vale.Math.Poly2.Bits_s.to_quad32",
"Vale.Math.Poly2_s.shift",
"Vale.AES.GF128.quad32_shift_left_1",
"Vale.Def.Types_s.reverse_bytes_nat32_reveal",
"Vale.Def.Types_s.quad32_xor_reveal",
"Vale.Math.Poly2.Lemmas.le... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20" | false | false | Vale.AES.GF128.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_shift_left_1 (a:poly) : Lemma
(requires degree a < 128)
(ensures to_quad32 (shift a 1) == quad32_shift_left_1 (to_quad32 a)) | [] | Vale.AES.GF128.lemma_shift_left_1 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma (requires Vale.Math.Poly2_s.degree a < 128)
(ensures
Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.shift a 1) ==
Vale.AES.GF128.quad32_shift_left_1 (Vale.Math.Poly2.Bits_s.to_quad32 a)) | {
"end_col": 4,
"end_line": 20,
"start_col": 2,
"start_line": 8
} |
FStar.Pervasives.Lemma | val lemma_reduce_rev_bits (a0 a1 a2 c: poly) (n: pos)
: Lemma
(requires
n == 64 /\ degree a0 < n + n /\ degree a1 < n + n /\ degree a2 < n + n /\ degree c < n)
(ensures
(let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = reverse a (nn - 1) i... | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full... | false | let lemma_reduce_rev_bits (a0 a1 a2 c:poly) (n:pos) : Lemma
(requires
n == 64 /\ // verification times out unless n is known
degree a0 < n + n /\
degree a1 < n + n /\
degree a2 < n + n /\
degree c < n
)
(ensures (
let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev ... | val lemma_reduce_rev_bits (a0 a1 a2 c: poly) (n: pos)
: Lemma
(requires
n == 64 /\ degree a0 < n + n /\ degree a1 < n + n /\ degree a2 < n + n /\ degree c < n)
(ensures
(let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = reverse a (nn - 1) i... | false | null | true | let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = reverse a (nn - 1) in
let y_10 = a0 +. shift (mask a1 n) n in
let y_0 = mask y_10 n in
let y_10c = swap y_10 n +. y_0 *. c in
let a = a0 +. shift a1 n +. shift a2 nn in
let x = reverse a (nn + nn - 1) in
let x0 = mask x n in
let x1 = mask (shift x (- n... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.mask",
"Vale.Math.Poly2.swap",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reduce_rev_bits (a0 a1 a2 c: poly) (n: pos)
: Lemma
(requires
n == 64 /\ degree a0 < n + n /\ degree a1 < n + n /\ degree a2 < n + n /\ degree c < n)
(ensures
(let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = reverse a (nn - 1) i... | [] | Vale.AES.GF128.lemma_reduce_rev_bits | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a0: Vale.Math.Poly2_s.poly ->
a1: Vale.Math.Poly2_s.poly ->
a2: Vale.Math.Poly2_s.poly ->
c: Vale.Math.Poly2_s.poly ->
n: Prims.pos
-> FStar.Pervasives.Lemma
(requires
n == 64 /\ Vale.Math.Poly2_s.degree a0 < n + n /\ Vale.Math.Poly2_s.degree a1 < n + n /\
Vale.Math.Poly2_s.... | {
"end_col": 3,
"end_line": 511,
"start_col": 1,
"start_line": 466
} |
FStar.Pervasives.Lemma | val lemma_reduce_rev_hi (x3 x2 h:poly) (n:pos) : Lemma
(requires
degree x3 < n /\
degree x2 < n /\
degree (monomial (n + n) +. h) == n + n /\
degree h < n /\
h.[0]
)
(ensures (
let nn = n + n in
let mm = monomial nn in
let m = monomial n in
let g = mm +. h in
let c = revers... | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full... | false | let lemma_reduce_rev_hi x3 x2 h n =
let n1 = n - 1 in
let nn = n + n in
let nn1 = n + n - 1 in
let mm = monomial nn in
let m = monomial n in
let g = mm +. h in
let c = reverse (shift h (-1)) n1 in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
let x3h = x3 *... | val lemma_reduce_rev_hi (x3 x2 h:poly) (n:pos) : Lemma
(requires
degree x3 < n /\
degree x2 < n /\
degree (monomial (n + n) +. h) == n + n /\
degree h < n /\
h.[0]
)
(ensures (
let nn = n + n in
let mm = monomial nn in
let m = monomial n in
let g = mm +. h in
let c = revers... | false | null | true | let n1 = n - 1 in
let nn = n + n in
let nn1 = n + n - 1 in
let mm = monomial nn in
let m = monomial n in
let g = mm +. h in
let c = reverse (shift h (- 1)) n1 in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
let x3h = x3 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemm... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Vale.Math.Poly2_s.reverse",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2.mask",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.swap",
"Prims.Cons",
... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_reduce_rev_hi (x3 x2 h:poly) (n:pos) : Lemma
(requires
degree x3 < n /\
degree x2 < n /\
degree (monomial (n + n) +. h) == n + n /\
degree h < n /\
h.[0]
)
(ensures (
let nn = n + n in
let mm = monomial nn in
let m = monomial n in
let g = mm +. h in
let c = revers... | [] | Vale.AES.GF128.lemma_reduce_rev_hi | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
x3: Vale.Math.Poly2_s.poly ->
x2: Vale.Math.Poly2_s.poly ->
h: Vale.Math.Poly2_s.poly ->
n: Prims.pos
-> FStar.Pervasives.Lemma
(requires
Vale.Math.Poly2_s.degree x3 < n /\ Vale.Math.Poly2_s.degree x2 < n /\
Vale.Math.Poly2_s.degree (Vale.Math.Poly2_s.monomial (n + n) +. h) == n... | {
"end_col": 3,
"end_line": 428,
"start_col": 35,
"start_line": 346
} |
FStar.Pervasives.Lemma | val lemma_shift_2_left_1 (lo hi:poly) : Lemma
(requires degree hi < 127 /\ degree lo < 128)
(ensures (
let n = monomial 128 in
let a = hi *. n +. lo in
let a' = shift a 1 in
let (lo', hi') = quad32_shift_2_left_1 (to_quad32 lo) (to_quad32 hi) in
lo' == to_quad32 (a' %. n) /\
hi' == to_quad32... | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": fal... | false | let lemma_shift_2_left_1 lo hi =
let n = monomial 128 in
let a = hi *. n +. lo in
let a' = shift a 1 in
let (qlo', qhi') = quad32_shift_2_left_1 (to_quad32 lo) (to_quad32 hi) in
reveal_to_quad32 lo;
reveal_to_quad32 hi;
reveal_to_quad32 (a' %. n);
reveal_to_quad32 (a' /. n);
lemma_zero_nth 32;
lemma... | val lemma_shift_2_left_1 (lo hi:poly) : Lemma
(requires degree hi < 127 /\ degree lo < 128)
(ensures (
let n = monomial 128 in
let a = hi *. n +. lo in
let a' = shift a 1 in
let (lo', hi') = quad32_shift_2_left_1 (to_quad32 lo) (to_quad32 hi) in
lo' == to_quad32 (a' %. n) /\
hi' == to_quad32... | false | null | true | let n = monomial 128 in
let a = hi *. n +. lo in
let a' = shift a 1 in
let qlo', qhi' = quad32_shift_2_left_1 (to_quad32 lo) (to_quad32 hi) in
reveal_to_quad32 lo;
reveal_to_quad32 hi;
reveal_to_quad32 (a' %. n);
reveal_to_quad32 (a' /. n);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth... | {
"checked_file": "Vale.AES.GF128.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Calc.fsti.checked"
],
"in... | [
"lemma"
] | [
"Vale.Math.Poly2_s.poly",
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Bits_s.to_quad32",
"Vale.Math.Poly2_s.div",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Arch.TypesNative.lemma_quad32_vec_equal",
"Vale.Math.Poly2.op_Slash_Dot",
... | [] | module Vale.AES.GF128
open FStar.Mul
open Vale.Arch.TypesNative
open Vale.Math.Poly2.Bits
#reset-options "--z3rlimit 20"
let lemma_shift_left_1 a =
reveal_to_quad32 a;
reveal_to_quad32 (shift a 1);
lemma_zero_nth 32;
lemma_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();... | false | false | Vale.AES.GF128.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_shift_2_left_1 (lo hi:poly) : Lemma
(requires degree hi < 127 /\ degree lo < 128)
(ensures (
let n = monomial 128 in
let a = hi *. n +. lo in
let a' = shift a 1 in
let (lo', hi') = quad32_shift_2_left_1 (to_quad32 lo) (to_quad32 hi) in
lo' == to_quad32 (a' %. n) /\
hi' == to_quad32... | [] | Vale.AES.GF128.lemma_shift_2_left_1 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GF128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Vale.Math.Poly2_s.poly -> hi: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree hi < 127 /\ Vale.Math.Poly2_s.degree lo < 128)
(ensures
(let n = Vale.Math.Poly2_s.monomial 128 in
let a = hi *. n +. lo in
let a' = Vale.Math.Poly2_s.shift a 1... | {
"end_col": 4,
"end_line": 57,
"start_col": 32,
"start_line": 22
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": tru... | false | let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len | let kam (len: BN.meta_len t_limbs) = | false | null | false | AM.mk_runtime_almost_mont #t_limbs len | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.AlmostMontgomery.mk_runtime_almost_mont",
"Hacl.Bignum.AlmostMontgomery.almost_mont"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | true | Hacl.Bignum32.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 kam : len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.AlmostMontgomery.almost_mont Hacl.Bignum32.t_limbs | [] | Hacl.Bignum32.kam | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.AlmostMontgomery.almost_mont Hacl.Bignum32.t_limbs | {
"end_col": 40,
"end_line": 17,
"start_col": 2,
"start_line": 17
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": tru... | false | let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len | let ke (len: BN.meta_len t_limbs) = | false | null | false | BE.mk_runtime_exp #t_limbs len | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Exponentiation.mk_runtime_exp",
"Hacl.Bignum.Exponentiation.exp"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | true | Hacl.Bignum32.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 ke : len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.Exponentiation.exp Hacl.Bignum32.t_limbs | [] | Hacl.Bignum32.ke | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.Exponentiation.exp Hacl.Bignum32.t_limbs | {
"end_col": 32,
"end_line": 21,
"start_col": 2,
"start_line": 21
} | |
Prims.Tot | val new_bn_from_bytes_be: BS.new_bn_from_bytes_be_st t_limbs | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let new_bn_from_bytes_be r len b =
BS.new_bn_from_bytes_be r len b | val new_bn_from_bytes_be: BS.new_bn_from_bytes_be_st t_limbs
let new_bn_from_bytes_be r len b = | false | null | false | BS.new_bn_from_bytes_be r len b | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"FStar.Monotonic.HyperHeap.rid",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.SafeAPI.new_bn_from_bytes_be",
"Hacl.Bignum32.t_limbs",
"LowStar.Buffer.buffer",
"Hacl.Bignum.Definitions.limb"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | true | Hacl.Bignum32.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 new_bn_from_bytes_be: BS.new_bn_from_bytes_be_st t_limbs | [] | Hacl.Bignum32.new_bn_from_bytes_be | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Bignum.SafeAPI.new_bn_from_bytes_be_st Hacl.Bignum32.t_limbs | {
"end_col": 33,
"end_line": 81,
"start_col": 2,
"start_line": 81
} |
Prims.Tot | val mont_ctx_free: MA.bn_field_free_st t_limbs | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mont_ctx_free k =
MA.bn_field_free k | val mont_ctx_free: MA.bn_field_free_st t_limbs
let mont_ctx_free k = | false | null | false | MA.bn_field_free k | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.MontArithmetic.bn_field_free",
"Prims.unit"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | true | Hacl.Bignum32.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 mont_ctx_free: MA.bn_field_free_st t_limbs | [] | Hacl.Bignum32.mont_ctx_free | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Bignum.MontArithmetic.bn_field_free_st Hacl.Bignum32.t_limbs | {
"end_col": 20,
"end_line": 61,
"start_col": 2,
"start_line": 61
} |
Prims.Tot | val new_bn_from_bytes_le: BS.new_bn_from_bytes_le_st t_limbs | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let new_bn_from_bytes_le r len b =
BS.new_bn_from_bytes_le r len b | val new_bn_from_bytes_le: BS.new_bn_from_bytes_le_st t_limbs
let new_bn_from_bytes_le r len b = | false | null | false | BS.new_bn_from_bytes_le r len b | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"FStar.Monotonic.HyperHeap.rid",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.SafeAPI.new_bn_from_bytes_le",
"Hacl.Bignum32.t_limbs",
"LowStar.Buffer.buffer",
"Hacl.Bignum.Definitions.limb"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | true | Hacl.Bignum32.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 new_bn_from_bytes_le: BS.new_bn_from_bytes_le_st t_limbs | [] | Hacl.Bignum32.new_bn_from_bytes_le | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Bignum.SafeAPI.new_bn_from_bytes_le_st Hacl.Bignum32.t_limbs | {
"end_col": 33,
"end_line": 84,
"start_col": 2,
"start_line": 84
} |
Prims.Tot | val lt_mask: len:_ -> BN.bn_lt_mask_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let lt_mask len a b =
BN.bn_lt_mask len a b | val lt_mask: len:_ -> BN.bn_lt_mask_st t_limbs len
let lt_mask len a b = | false | null | false | BN.bn_lt_mask len a b | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.bn_lt_mask",
"Hacl.Bignum.Definitions.limb"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 lt_mask: len:_ -> BN.bn_lt_mask_st t_limbs len | [] | Hacl.Bignum32.lt_mask | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Lib.IntTypes.size_t -> Hacl.Bignum.bn_lt_mask_st Hacl.Bignum32.t_limbs len | {
"end_col": 23,
"end_line": 93,
"start_col": 2,
"start_line": 93
} |
Prims.Tot | val eq_mask: len:_ -> BN.bn_eq_mask_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let eq_mask len a b =
BN.bn_eq_mask len a b | val eq_mask: len:_ -> BN.bn_eq_mask_st t_limbs len
let eq_mask len a b = | false | null | false | BN.bn_eq_mask len a b | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.bn_eq_mask",
"Hacl.Bignum.Definitions.limb"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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_mask: len:_ -> BN.bn_eq_mask_st t_limbs len | [] | Hacl.Bignum32.eq_mask | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Lib.IntTypes.size_t -> Hacl.Bignum.bn_eq_mask_st Hacl.Bignum32.t_limbs len | {
"end_col": 23,
"end_line": 96,
"start_col": 2,
"start_line": 96
} |
Prims.Tot | val add: len:BN.meta_len t_limbs -> BN.bn_add_eq_len_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let add len a b res =
(ke len).BE.bn.BN.add a b res | val add: len:BN.meta_len t_limbs -> BN.bn_add_eq_len_st t_limbs len
let add len a b res = | false | null | false | (ke len).BE.bn.BN.add a b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.__proj__Mkbn__item__add",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Hacl.Bignum32.ke",
"Hacl.Spec.Bignum.Base.carry"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 add: len:BN.meta_len t_limbs -> BN.bn_add_eq_len_st t_limbs len | [] | Hacl.Bignum32.add | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.bn_add_eq_len_st Hacl.Bignum32.t_limbs len | {
"end_col": 31,
"end_line": 24,
"start_col": 2,
"start_line": 24
} |
Prims.Tot | val mont_ctx_init: len:BN.meta_len t_limbs -> MA.bn_field_init_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n | val mont_ctx_init: len:BN.meta_len t_limbs -> MA.bn_field_init_st t_limbs len
let mont_ctx_init len r n = | false | null | false | MA.bn_field_init len (ke len).BE.precompr2 r n | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"FStar.Monotonic.HyperHeap.rid",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.MontArithmetic.bn_field_init",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__precompr2",
"Hacl.Bignum32.ke",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mont_ctx_init: len:BN.meta_len t_limbs -> MA.bn_field_init_st t_limbs len | [] | Hacl.Bignum32.mont_ctx_init | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.MontArithmetic.bn_field_init_st Hacl.Bignum32.t_limbs len | {
"end_col": 48,
"end_line": 58,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | val add_mod: len:BN.meta_len t_limbs -> BN.bn_add_mod_n_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res | val add_mod: len:BN.meta_len t_limbs -> BN.bn_add_mod_n_st t_limbs len
let add_mod len n a b res = | false | null | false | (ke len).BE.bn.BN.add_mod_n n a b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.__proj__Mkbn__item__add_mod_n",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Hacl.Bignum32.ke",
"Prims.unit"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 add_mod: len:BN.meta_len t_limbs -> BN.bn_add_mod_n_st t_limbs len | [] | Hacl.Bignum32.add_mod | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.bn_add_mod_n_st Hacl.Bignum32.t_limbs len | {
"end_col": 39,
"end_line": 30,
"start_col": 2,
"start_line": 30
} |
Prims.Tot | val sub: len:BN.meta_len t_limbs -> BN.bn_sub_eq_len_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let sub len a b res =
(ke len).BE.bn.BN.sub a b res | val sub: len:BN.meta_len t_limbs -> BN.bn_sub_eq_len_st t_limbs len
let sub len a b res = | false | null | false | (ke len).BE.bn.BN.sub a b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.__proj__Mkbn__item__sub",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Hacl.Bignum32.ke",
"Hacl.Spec.Bignum.Base.carry"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 sub: len:BN.meta_len t_limbs -> BN.bn_sub_eq_len_st t_limbs len | [] | Hacl.Bignum32.sub | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.bn_sub_eq_len_st Hacl.Bignum32.t_limbs len | {
"end_col": 31,
"end_line": 27,
"start_col": 2,
"start_line": 27
} |
Prims.Tot | val bn_slow_precomp (len: BN.meta_len t_limbs) : BR.bn_mod_slow_precomp_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": tru... | false | let bn_slow_precomp (len:BN.meta_len t_limbs) : BR.bn_mod_slow_precomp_st t_limbs len =
BR.bn_mod_slow_precomp (kam len) | val bn_slow_precomp (len: BN.meta_len t_limbs) : BR.bn_mod_slow_precomp_st t_limbs len
let bn_slow_precomp (len: BN.meta_len t_limbs) : BR.bn_mod_slow_precomp_st t_limbs len = | false | null | false | BR.bn_mod_slow_precomp (kam len) | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.ModReduction.bn_mod_slow_precomp",
"Hacl.Bignum32.kam",
"Hacl.Bignum.ModReduction.bn_mod_slow_precomp_st"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 bn_slow_precomp (len: BN.meta_len t_limbs) : BR.bn_mod_slow_precomp_st t_limbs len | [] | Hacl.Bignum32.bn_slow_precomp | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.ModReduction.bn_mod_slow_precomp_st Hacl.Bignum32.t_limbs len | {
"end_col": 34,
"end_line": 43,
"start_col": 2,
"start_line": 43
} |
Prims.Tot | val sub_mod: len:BN.meta_len t_limbs -> BN.bn_sub_mod_n_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res | val sub_mod: len:BN.meta_len t_limbs -> BN.bn_sub_mod_n_st t_limbs len
let sub_mod len n a b res = | false | null | false | (ke len).BE.bn.BN.sub_mod_n n a b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.__proj__Mkbn__item__sub_mod_n",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Hacl.Bignum32.ke",
"Prims.unit"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 sub_mod: len:BN.meta_len t_limbs -> BN.bn_sub_mod_n_st t_limbs len | [] | Hacl.Bignum32.sub_mod | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.bn_sub_mod_n_st Hacl.Bignum32.t_limbs len | {
"end_col": 39,
"end_line": 33,
"start_col": 2,
"start_line": 33
} |
Prims.Tot | val mod_inv_prime_vartime: len:BN.meta_len t_limbs -> BS.bn_mod_inv_prime_safe_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_inv_prime_vartime len n a res =
BS.mk_bn_mod_inv_prime_safe len (ke len).BE.exp_vt n a res | val mod_inv_prime_vartime: len:BN.meta_len t_limbs -> BS.bn_mod_inv_prime_safe_st t_limbs len
let mod_inv_prime_vartime len n a res = | false | null | false | BS.mk_bn_mod_inv_prime_safe len (ke len).BE.exp_vt n a res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.SafeAPI.mk_bn_mod_inv_prime_safe",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_vt",
"Hacl.Bignum32.ke",
"Prims.bool"
] | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_inv_prime_vartime: len:BN.meta_len t_limbs -> BS.bn_mod_inv_prime_safe_st t_limbs len | [] | Hacl.Bignum32.mod_inv_prime_vartime | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.SafeAPI.bn_mod_inv_prime_safe_st Hacl.Bignum32.t_limbs len | {
"end_col": 60,
"end_line": 55,
"start_col": 2,
"start_line": 55
} |
Prims.Tot | val mod_inv_prime_vartime_precomp: len:Ghost.erased _ -> BS.bn_mod_inv_prime_ctx_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_inv_prime_vartime_precomp len k a res =
let len1 = MA.bn_field_get_len k in
BS.mk_bn_mod_inv_prime_ctx len
(BI.mk_bn_mod_inv_prime_precomp len1 (ke len1).BE.exp_vt_precomp) k a res | val mod_inv_prime_vartime_precomp: len:Ghost.erased _ -> BS.bn_mod_inv_prime_ctx_st t_limbs len
let mod_inv_prime_vartime_precomp len k a res = | false | null | false | let len1 = MA.bn_field_get_len k in
BS.mk_bn_mod_inv_prime_ctx len
(BI.mk_bn_mod_inv_prime_precomp len1 (ke len1).BE.exp_vt_precomp)
k
a
res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"FStar.Ghost.erased",
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"FStar.Ghost.reveal",
"Hacl.Bignum.SafeAPI.mk_bn_mod_inv_prime_ctx",
"Hacl.Bignum.ModInv.mk_bn_mod_inv_prime_precomp",
"Hacl.Bignum.Exponentiation.__pr... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_inv_prime_vartime_precomp: len:Ghost.erased _ -> BS.bn_mod_inv_prime_ctx_st t_limbs len | [] | Hacl.Bignum32.mod_inv_prime_vartime_precomp | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: FStar.Ghost.erased (Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs)
-> Hacl.Bignum.SafeAPI.bn_mod_inv_prime_ctx_st Hacl.Bignum32.t_limbs (FStar.Ghost.reveal len) | {
"end_col": 77,
"end_line": 78,
"start_col": 47,
"start_line": 75
} |
Prims.Tot | val mod: len:BN.meta_len t_limbs -> BS.bn_mod_slow_safe_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod len n a res =
BS.mk_bn_mod_slow_safe len (BR.mk_bn_mod_slow len (kam len).AM.precomp (bn_slow_precomp len)) n a res | val mod: len:BN.meta_len t_limbs -> BS.bn_mod_slow_safe_st t_limbs len
let mod len n a res = | false | null | false | BS.mk_bn_mod_slow_safe len
(BR.mk_bn_mod_slow len (kam len).AM.precomp (bn_slow_precomp len))
n
a
res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.SafeAPI.mk_bn_mod_slow_safe",
"Hacl.Bignum.ModReduction.mk_bn_mod_slow",
"Hacl.Bignum.AlmostMontgomery.__proj__Mkalmost_mont__item__pr... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod: len:BN.meta_len t_limbs -> BS.bn_mod_slow_safe_st t_limbs len | [] | Hacl.Bignum32.mod | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.SafeAPI.bn_mod_slow_safe_st Hacl.Bignum32.t_limbs len | {
"end_col": 103,
"end_line": 46,
"start_col": 2,
"start_line": 46
} |
Prims.Tot | val mod_precomp: len:Ghost.erased _ -> BS.bn_mod_slow_ctx_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_precomp len k a res =
let len1 = MA.bn_field_get_len k in
BS.bn_mod_ctx len (bn_slow_precomp len1) k a res | val mod_precomp: len:Ghost.erased _ -> BS.bn_mod_slow_ctx_st t_limbs len
let mod_precomp len k a res = | false | null | false | let len1 = MA.bn_field_get_len k in
BS.bn_mod_ctx len (bn_slow_precomp len1) k a res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"FStar.Ghost.erased",
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.Ghost.reveal",
"Hacl.Bignum.SafeAPI.bn_mod_ctx",
"Hacl.Bignum32.bn_slow... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_precomp: len:Ghost.erased _ -> BS.bn_mod_slow_ctx_st t_limbs len | [] | Hacl.Bignum32.mod_precomp | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: FStar.Ghost.erased (Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs)
-> Hacl.Bignum.SafeAPI.bn_mod_slow_ctx_st Hacl.Bignum32.t_limbs (FStar.Ghost.reveal len) | {
"end_col": 50,
"end_line": 65,
"start_col": 29,
"start_line": 63
} |
Prims.Tot | val mod_exp_vartime: len:BN.meta_len t_limbs -> BS.bn_mod_exp_safe_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_exp_vartime len n a bBits b res =
BS.mk_bn_mod_exp_safe len (ke len).BE.exp_check (ke len).BE.exp_vt n a bBits b res | val mod_exp_vartime: len:BN.meta_len t_limbs -> BS.bn_mod_exp_safe_st t_limbs len
let mod_exp_vartime len n a bBits b res = | false | null | false | BS.mk_bn_mod_exp_safe len (ke len).BE.exp_check (ke len).BE.exp_vt n a bBits b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.Definitions.blocks0",
"Lib.IntT... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_exp_vartime: len:BN.meta_len t_limbs -> BS.bn_mod_exp_safe_st t_limbs len | [] | Hacl.Bignum32.mod_exp_vartime | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.SafeAPI.bn_mod_exp_safe_st Hacl.Bignum32.t_limbs len | {
"end_col": 84,
"end_line": 49,
"start_col": 2,
"start_line": 49
} |
Prims.Tot | val mod_exp_vartime_precomp: len:Ghost.erased _ -> BS.bn_mod_exp_ctx_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_exp_vartime_precomp len k a bBits b res =
let len1 = MA.bn_field_get_len k in
BS.mk_bn_mod_exp_ctx len (ke len1).BE.exp_vt_precomp k a bBits b res | val mod_exp_vartime_precomp: len:Ghost.erased _ -> BS.bn_mod_exp_ctx_st t_limbs len
let mod_exp_vartime_precomp len k a bBits b res = | false | null | false | let len1 = MA.bn_field_get_len k in
BS.mk_bn_mod_exp_ctx len (ke len1).BE.exp_vt_precomp k a bBits b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"FStar.Ghost.erased",
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"FStar.Ghost.reveal",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.blocks0",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Hacl.Bignum.SafeAPI.mk_b... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_exp_vartime_precomp: len:Ghost.erased _ -> BS.bn_mod_exp_ctx_st t_limbs len | [] | Hacl.Bignum32.mod_exp_vartime_precomp | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: FStar.Ghost.erased (Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs)
-> Hacl.Bignum.SafeAPI.bn_mod_exp_ctx_st Hacl.Bignum32.t_limbs (FStar.Ghost.reveal len) | {
"end_col": 70,
"end_line": 69,
"start_col": 49,
"start_line": 67
} |
Prims.Tot | val mod_exp_consttime: len:BN.meta_len t_limbs -> BS.bn_mod_exp_safe_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_exp_consttime len n a bBits b res =
BS.mk_bn_mod_exp_safe len (ke len).BE.exp_check (ke len).BE.exp_ct n a bBits b res | val mod_exp_consttime: len:BN.meta_len t_limbs -> BS.bn_mod_exp_safe_st t_limbs len
let mod_exp_consttime len n a bBits b res = | false | null | false | BS.mk_bn_mod_exp_safe len (ke len).BE.exp_check (ke len).BE.exp_ct n a bBits b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.Definitions.blocks0",
"Lib.IntT... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_exp_consttime: len:BN.meta_len t_limbs -> BS.bn_mod_exp_safe_st t_limbs len | [] | Hacl.Bignum32.mod_exp_consttime | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs
-> Hacl.Bignum.SafeAPI.bn_mod_exp_safe_st Hacl.Bignum32.t_limbs len | {
"end_col": 84,
"end_line": 52,
"start_col": 2,
"start_line": 52
} |
Prims.Tot | val mod_exp_consttime_precomp: len:Ghost.erased _ -> BS.bn_mod_exp_ctx_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mod_exp_consttime_precomp len k a bBits b res =
let len1 = MA.bn_field_get_len k in
BS.mk_bn_mod_exp_ctx len (ke len1).BE.exp_ct_precomp k a bBits b res | val mod_exp_consttime_precomp: len:Ghost.erased _ -> BS.bn_mod_exp_ctx_st t_limbs len
let mod_exp_consttime_precomp len k a bBits b res = | false | null | false | let len1 = MA.bn_field_get_len k in
BS.mk_bn_mod_exp_ctx len (ke len1).BE.exp_ct_precomp k a bBits b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"FStar.Ghost.erased",
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"FStar.Ghost.reveal",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.blocks0",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Hacl.Bignum.SafeAPI.mk_b... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mod_exp_consttime_precomp: len:Ghost.erased _ -> BS.bn_mod_exp_ctx_st t_limbs len | [] | Hacl.Bignum32.mod_exp_consttime_precomp | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: FStar.Ghost.erased (Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs)
-> Hacl.Bignum.SafeAPI.bn_mod_exp_ctx_st Hacl.Bignum32.t_limbs (FStar.Ghost.reveal len) | {
"end_col": 70,
"end_line": 73,
"start_col": 51,
"start_line": 71
} |
Prims.Tot | val bn_to_bytes_be: len:_ -> Hacl.Bignum.Convert.bn_to_bytes_be_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let bn_to_bytes_be len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_be false len b res | val bn_to_bytes_be: len:_ -> Hacl.Bignum.Convert.bn_to_bytes_be_st t_limbs len
let bn_to_bytes_be len b res = | false | null | false | Hacl.Bignum.Convert.mk_bn_to_bytes_be false len b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.I... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 bn_to_bytes_be: len:_ -> Hacl.Bignum.Convert.bn_to_bytes_be_st t_limbs len | [] | Hacl.Bignum32.bn_to_bytes_be | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.numbytes Hacl.Bignum32.t_limbs *
Lib.IntTypes.v (Hacl.Bignum.Definitions.blocks len
(Lib.IntTypes.size (Lib.IntTypes.numbytes Hacl.Bignum32.t_limbs))) <=
Lib.IntTypes.max_size_t }
-> Hacl... | {
"end_col": 55,
"end_line": 87,
"start_col": 2,
"start_line": 87
} |
Prims.Tot | val sqr: len:BN.meta_len t_limbs -> a:lbignum t_limbs len -> BN.bn_karatsuba_sqr_st t_limbs len a | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let sqr len a res =
(ke len).BE.bn.BN.sqr a res | val sqr: len:BN.meta_len t_limbs -> a:lbignum t_limbs len -> BN.bn_karatsuba_sqr_st t_limbs len a
let sqr len a res = | false | null | false | (ke len).BE.bn.BN.sqr a res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum32.lbignum",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.__proj__Mkbn__item__sqr",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Hacl.Bignum32.ke",
"Prim... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 sqr: len:BN.meta_len t_limbs -> a:lbignum t_limbs len -> BN.bn_karatsuba_sqr_st t_limbs len a | [] | Hacl.Bignum32.sqr | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs ->
a: Hacl.Bignum32.lbignum Hacl.Bignum32.t_limbs len
-> Hacl.Bignum.bn_karatsuba_sqr_st Hacl.Bignum32.t_limbs len a | {
"end_col": 29,
"end_line": 39,
"start_col": 2,
"start_line": 39
} |
Prims.Tot | val mul: len:BN.meta_len t_limbs -> a:lbignum t_limbs len -> BN.bn_karatsuba_mul_st t_limbs len a | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let mul len a b res =
(ke len).BE.bn.BN.mul a b res | val mul: len:BN.meta_len t_limbs -> a:lbignum t_limbs len -> BN.bn_karatsuba_mul_st t_limbs len a
let mul len a b res = | false | null | false | (ke len).BE.bn.BN.mul a b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum32.lbignum",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.__proj__Mkbn__item__mul",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Hacl.Bignum32.ke",
"Prim... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 mul: len:BN.meta_len t_limbs -> a:lbignum t_limbs len -> BN.bn_karatsuba_mul_st t_limbs len a | [] | Hacl.Bignum32.mul | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Bignum.meta_len Hacl.Bignum32.t_limbs ->
a: Hacl.Bignum32.lbignum Hacl.Bignum32.t_limbs len
-> Hacl.Bignum.bn_karatsuba_mul_st Hacl.Bignum32.t_limbs len a | {
"end_col": 31,
"end_line": 36,
"start_col": 2,
"start_line": 36
} |
Prims.Tot | val bn_to_bytes_le: len:_ -> Hacl.Bignum.Convert.bn_to_bytes_le_st t_limbs len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModInv",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": t... | false | let bn_to_bytes_le len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_le false len b res | val bn_to_bytes_le: len:_ -> Hacl.Bignum.Convert.bn_to_bytes_le_st t_limbs len
let bn_to_bytes_le len b res = | false | null | false | Hacl.Bignum.Convert.mk_bn_to_bytes_le false len b res | {
"checked_file": "Hacl.Bignum32.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.ModReduction.fst.checked",
"Hacl.Bignum.ModInv.fst.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Ha... | [
"total"
] | [
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Bignum32.t_limbs",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.I... | [] | module Hacl.Bignum32
open FStar.Mul
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BR = Hacl.Bignum.ModReduction
module AM = Hacl.Bignum.AlmostMontgomery
module MA = Hacl.Bignum.MontArithmetic
module BI = Hacl.Bignum.ModInv
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel ... | false | false | Hacl.Bignum32.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 bn_to_bytes_le: len:_ -> Hacl.Bignum.Convert.bn_to_bytes_le_st t_limbs len | [] | Hacl.Bignum32.bn_to_bytes_le | {
"file_name": "code/bignum/Hacl.Bignum32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.numbytes Hacl.Bignum32.t_limbs *
Lib.IntTypes.v (Hacl.Bignum.Definitions.blocks len
(Lib.IntTypes.size (Lib.IntTypes.numbytes Hacl.Bignum32.t_limbs))) <=
Lib.IntTypes.max_size_t }
-> Hacl... | {
"end_col": 55,
"end_line": 90,
"start_col": 2,
"start_line": 90
} |
Prims.Tot | val coerce_to_normal (#a: Type0) (x: a) : y: (normal a){x == y} | [
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder // open so that we don't",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",... | false | let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x | val coerce_to_normal (#a: Type0) (x: a) : y: (normal a){x == y}
let coerce_to_normal (#a: Type0) (x: a) : y: (normal a){x == y} = | false | null | false | x | {
"checked_file": "Vale.Transformers.PeepHole.fsti.checked",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Lemmas.fsti.checked",
"Vale.X64.Instructions_s.fsti.chec... | [
"total"
] | [
"Vale.X64.Instruction_s.normal",
"Prims.eq2"
] | [] | (**
This module defines a framework for peephole transformers. It needs
to be instantiated with an actual pattern to generate a verified
peephole transform. In particular, it needs to be provided a
[peephole], and an [input_hint] to obtain a new transformer.
A [peephole] is a function that converts a l... | false | false | Vale.Transformers.PeepHole.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 coerce_to_normal (#a: Type0) (x: a) : y: (normal a){x == y} | [] | Vale.Transformers.PeepHole.coerce_to_normal | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.PeepHole.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: a -> y: Vale.X64.Instruction_s.normal a {x == y} | {
"end_col": 64,
"end_line": 93,
"start_col": 63,
"start_line": 93
} |
Prims.GTot | val peephole_correct (p: pre_peephole) (is: list ins) (s: machine_state) : GTot Type0 | [
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder // open so that we don't",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",... | false | let peephole_correct (p:pre_peephole) (is:list ins) (s:machine_state) : GTot Type0 =
match p.ph is with
| None -> True
| Some is' ->
let s1 = eval_inss is s in
let s2 = eval_inss is' s in
s1.ms_ok ==> equiv_states s1 s2 | val peephole_correct (p: pre_peephole) (is: list ins) (s: machine_state) : GTot Type0
let peephole_correct (p: pre_peephole) (is: list ins) (s: machine_state) : GTot Type0 = | false | null | false | match p.ph is with
| None -> True
| Some is' ->
let s1 = eval_inss is s in
let s2 = eval_inss is' s in
s1.ms_ok ==> equiv_states s1 s2 | {
"checked_file": "Vale.Transformers.PeepHole.fsti.checked",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Lemmas.fsti.checked",
"Vale.X64.Instructions_s.fsti.chec... | [
"sometrivial"
] | [
"Vale.Transformers.PeepHole.pre_peephole",
"Prims.list",
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.PeepHole.__proj__Mkpre_peephole__item__ph",
"Prims.l_True",
"Prims.l_imp",
"Prims.b2t",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state_... | [] | (**
This module defines a framework for peephole transformers. It needs
to be instantiated with an actual pattern to generate a verified
peephole transform. In particular, it needs to be provided a
[peephole], and an [input_hint] to obtain a new transformer.
A [peephole] is a function that converts a l... | false | false | Vale.Transformers.PeepHole.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 peephole_correct (p: pre_peephole) (is: list ins) (s: machine_state) : GTot Type0 | [] | Vale.Transformers.PeepHole.peephole_correct | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.PeepHole.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
p: Vale.Transformers.PeepHole.pre_peephole ->
is: Prims.list Vale.X64.Machine_Semantics_s.ins ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.GTot Type0 | {
"end_col": 35,
"end_line": 60,
"start_col": 2,
"start_line": 55
} |
Prims.GTot | val eval_inss (is: list ins) (s: machine_state) : GTot machine_state | [
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder // open so that we don't",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",... | false | let rec eval_inss (is:list ins) (s:machine_state) : GTot machine_state =
match is with
| [] -> s
| i :: is' -> eval_inss is' (machine_eval_ins i s) | val eval_inss (is: list ins) (s: machine_state) : GTot machine_state
let rec eval_inss (is: list ins) (s: machine_state) : GTot machine_state = | false | null | false | match is with
| [] -> s
| i :: is' -> eval_inss is' (machine_eval_ins i s) | {
"checked_file": "Vale.Transformers.PeepHole.fsti.checked",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Lemmas.fsti.checked",
"Vale.X64.Instructions_s.fsti.chec... | [
"sometrivial"
] | [
"Prims.list",
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.PeepHole.eval_inss",
"Vale.X64.Machine_Semantics_s.machine_eval_ins"
] | [] | (**
This module defines a framework for peephole transformers. It needs
to be instantiated with an actual pattern to generate a verified
peephole transform. In particular, it needs to be provided a
[peephole], and an [input_hint] to obtain a new transformer.
A [peephole] is a function that converts a l... | false | false | Vale.Transformers.PeepHole.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 eval_inss (is: list ins) (s: machine_state) : GTot machine_state | [
"recursion"
] | Vale.Transformers.PeepHole.eval_inss | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.PeepHole.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | is: Prims.list Vale.X64.Machine_Semantics_s.ins -> s: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.GTot Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 52,
"end_line": 52,
"start_col": 2,
"start_line": 50
} |
FStar.Pervasives.Lemma | val lemma_double_update_reg (dst: operand64) (s0 s1 s2 s3: machine_state) (v v_fin: nat64)
: Lemma
(requires
((OReg? dst) /\ (valid_dst_operand64 dst s0) /\
(s1 == update_operand64_preserve_flags'' dst v s0 s0) /\
(s2 == update_operand64_preserve_flags'' dst v_fin s1 s1) /\
... | [
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder // open so that we don't",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",... | false | let lemma_double_update_reg (dst:operand64) (s0 s1 s2 s3:machine_state) (v v_fin:nat64) :
Lemma
(requires (
(OReg? dst) /\
(valid_dst_operand64 dst s0) /\
(s1 == update_operand64_preserve_flags'' dst v s0 s0) /\
(s2 == update_operand64_preserve_flags'' dst v_fin s1 s1) /\
(... | val lemma_double_update_reg (dst: operand64) (s0 s1 s2 s3: machine_state) (v v_fin: nat64)
: Lemma
(requires
((OReg? dst) /\ (valid_dst_operand64 dst s0) /\
(s1 == update_operand64_preserve_flags'' dst v s0 s0) /\
(s2 == update_operand64_preserve_flags'' dst v_fin s1 s1) /\
... | false | null | true | match dst with | OReg r -> assert (equiv_states_ext s2 s3) | {
"checked_file": "Vale.Transformers.PeepHole.fsti.checked",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Lemmas.fsti.checked",
"Vale.X64.Instructions_s.fsti.chec... | [
"lemma"
] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Prims._assert",
"Vale.Transformers.InstructionReorder.equiv_states_ext",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Machine_s.uu___is_OReg",
"Vale.X64.... | [] | (**
This module defines a framework for peephole transformers. It needs
to be instantiated with an actual pattern to generate a verified
peephole transform. In particular, it needs to be provided a
[peephole], and an [input_hint] to obtain a new transformer.
A [peephole] is a function that converts a l... | false | false | Vale.Transformers.PeepHole.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 lemma_double_update_reg (dst: operand64) (s0 s1 s2 s3: machine_state) (v v_fin: nat64)
: Lemma
(requires
((OReg? dst) /\ (valid_dst_operand64 dst s0) /\
(s1 == update_operand64_preserve_flags'' dst v s0 s0) /\
(s2 == update_operand64_preserve_flags'' dst v_fin s1 s1) /\
... | [] | Vale.Transformers.PeepHole.lemma_double_update_reg | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.PeepHole.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Machine_s.operand64 ->
s0: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state ->
s3: Vale.X64.Machine_Semantics_s.machine_state ->
v: Vale.X64.Machine_s.nat64 ->
v_fin: Vale.X64.Machine... | {
"end_col": 45,
"end_line": 119,
"start_col": 2,
"start_line": 118
} |
FStar.Pervasives.Lemma | val lemma_update_to_valid_destination_keeps_it_as_valid_src
(o: operand64)
(s: machine_state)
(v: nat64)
: Lemma (requires (valid_dst_operand64 o s))
(ensures
(let s' = update_operand64_preserve_flags'' o v s s in
valid_src_operand64_and_taint o s' /\ eval_operand o s' == v... | [
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder // open so that we don't",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",... | false | let lemma_update_to_valid_destination_keeps_it_as_valid_src (o:operand64) (s:machine_state) (v:nat64) :
Lemma
(requires (valid_dst_operand64 o s))
(ensures (
let s' = update_operand64_preserve_flags'' o v s s in
valid_src_operand64_and_taint o s' /\
eval_operand o s' == v)) =
reveal_... | val lemma_update_to_valid_destination_keeps_it_as_valid_src
(o: operand64)
(s: machine_state)
(v: nat64)
: Lemma (requires (valid_dst_operand64 o s))
(ensures
(let s' = update_operand64_preserve_flags'' o v s s in
valid_src_operand64_and_taint o s' /\ eval_operand o s' == v... | false | null | true | reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
get_heap_val64_reveal () | {
"checked_file": "Vale.Transformers.PeepHole.fsti.checked",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Lemmas.fsti.checked",
"Vale.X64.Instructions_s.fsti.chec... | [
"lemma"
] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_s.nat64",
"Vale.Arch.MachineHeap_s.get_heap_val64_reveal",
"Prims.unit",
"Vale.Arch.MachineHeap_s.update_heap64_reveal",
"FStar.Pervasives.reveal_opaque",
"Prims.int",
"Vale.Arch.MachineHeap_s.machine_hea... | [] | (**
This module defines a framework for peephole transformers. It needs
to be instantiated with an actual pattern to generate a verified
peephole transform. In particular, it needs to be provided a
[peephole], and an [input_hint] to obtain a new transformer.
A [peephole] is a function that converts a l... | false | false | Vale.Transformers.PeepHole.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"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 lemma_update_to_valid_destination_keeps_it_as_valid_src
(o: operand64)
(s: machine_state)
(v: nat64)
: Lemma (requires (valid_dst_operand64 o s))
(ensures
(let s' = update_operand64_preserve_flags'' o v s s in
valid_src_operand64_and_taint o s' /\ eval_operand o s' == v... | [] | Vale.Transformers.PeepHole.lemma_update_to_valid_destination_keeps_it_as_valid_src | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.PeepHole.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
o: Vale.X64.Machine_s.operand64 ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
v: Vale.X64.Machine_s.nat64
-> FStar.Pervasives.Lemma (requires Vale.X64.Machine_Semantics_s.valid_dst_operand64 o s)
(ensures
(let s' = Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags'' o v s s... | {
"end_col": 26,
"end_line": 105,
"start_col": 2,
"start_line": 103
} |
Prims.Tot | val return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0 | val return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1)
let return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1) = | false | null | false | fun s0 -> x, s0 | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [
"total"
] | [
"FStar.Preorder.preorder",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.MST.repr",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1) | [] | FStar.MST.return | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type -> x: a -> state: Type -> rel: FStar.Preorder.preorder state
-> FStar.MST.repr a state rel (fun _ -> Prims.l_True) (fun s0 r s1 -> r == x /\ s0 == s1) | {
"end_col": 17,
"end_line": 48,
"start_col": 2,
"start_line": 48
} |
FStar.MST.MSTATE | val get: #state: Type u#2 -> #rel: P.preorder state -> Prims.unit
-> MSTATE state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATE state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1)
=
MSTATE?.reflect (fun s0 -> s0, s0) | val get: #state: Type u#2 -> #rel: P.preorder state -> Prims.unit
-> MSTATE state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1)
let get (#state: Type u#2) (#rel: P.preorder state) ()
: MSTATE state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1) = | true | null | false | MSTATE?.reflect (fun s0 -> s0, s0) | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [] | [
"FStar.Preorder.preorder",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 get: #state: Type u#2 -> #rel: P.preorder state -> Prims.unit
-> MSTATE state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1) | [] | FStar.MST.get | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.MST.MSTATE state | {
"end_col": 36,
"end_line": 120,
"start_col": 2,
"start_line": 120
} |
FStar.MST.MSTATE | val put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATE unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let put (#state:Type u#2) (#rel:P.preorder state) (s:state)
: MSTATE unit state rel
(fun s0 -> rel s0 s)
(fun _ _ s1 -> s1 == s)
=
MSTATE?.reflect (fun _ -> (), s) | val put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATE unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s)
let put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATE unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s) = | true | null | false | MSTATE?.reflect (fun _ -> (), s) | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [] | [
"FStar.Preorder.preorder",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATE unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s) | [] | FStar.MST.put | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: state -> FStar.MST.MSTATE Prims.unit | {
"end_col": 34,
"end_line": 128,
"start_col": 2,
"start_line": 128
} |
Prims.Tot | val lift_mst_total_mst
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req: pre_t state)
(ens: post_t state a)
(f: MSTTotal.repr a state rel req ens)
: repr a state rel req ens | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let lift_mst_total_mst (a:Type)
(state:Type u#2) (rel:P.preorder state)
(req:pre_t state) (ens:post_t state a)
(f:MSTTotal.repr a state rel req ens)
: repr a state rel req ens
= fun s0 -> f s0 | val lift_mst_total_mst
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req: pre_t state)
(ens: post_t state a)
(f: MSTTotal.repr a state rel req ens)
: repr a state rel req ens
let lift_mst_total_mst
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
... | false | null | false | fun s0 -> f s0 | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [
"total"
] | [
"FStar.Preorder.preorder",
"FStar.MST.pre_t",
"FStar.MST.post_t",
"FStar.MSTTotal.repr",
"FStar.Pervasives.Native.tuple2",
"FStar.MST.repr"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 lift_mst_total_mst
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req: pre_t state)
(ens: post_t state a)
(f: MSTTotal.repr a state rel req ens)
: repr a state rel req ens | [] | FStar.MST.lift_mst_total_mst | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
state: Type ->
rel: FStar.Preorder.preorder state ->
req: FStar.MST.pre_t state ->
ens: FStar.MST.post_t state a ->
f: FStar.MSTTotal.repr a state rel req ens
-> FStar.MST.repr a state rel req ens | {
"end_col": 16,
"end_line": 245,
"start_col": 2,
"start_line": 245
} |
Prims.Pure | val subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req... | val subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s... | false | null | false | f | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [] | [
"FStar.Preorder.preorder",
"FStar.MST.pre_t",
"FStar.MST.post_t",
"FStar.MST.repr",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_True"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s... | [] | FStar.MST.subcomp | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
state: Type ->
rel: FStar.Preorder.preorder state ->
req_f: FStar.MST.pre_t state ->
ens_f: FStar.MST.post_t state a ->
req_g: FStar.MST.pre_t state ->
ens_g: FStar.MST.post_t state a ->
f: FStar.MST.repr a state rel req_f ens_f
-> Prims.Pure (FStar.MST.repr a state rel req... | {
"end_col": 3,
"end_line": 84,
"start_col": 2,
"start_line": 84
} |
Prims.Tot | val lift_pure_mst
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1)))) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let lift_pure_mst
(a:Type)
(wp:pure_wp a)
(state:Type u#2)
(rel:P.preorder state)
(f:eqtype_as_type unit -> PURE a wp)
: repr a state rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~ (wp (fun r -> r =!= x \/ s0 =!= s1))))
=
elim_pure_wp_mon... | val lift_pure_mst
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1))))
let lif... | false | null | false | elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
x, s0 | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [
"total"
] | [
"Prims.pure_wp",
"FStar.Preorder.preorder",
"FStar.Pervasives.eqtype_as_type",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"FStar.MST.repr",
"Prims.l_True",
"Prims.l_and",
"Prims.l_not",
"Prims.l_or",
"... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 lift_pure_mst
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1)))) | [] | FStar.MST.lift_pure_mst | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
wp: Prims.pure_wp a ->
state: Type ->
rel: FStar.Preorder.preorder state ->
f: (_: FStar.Pervasives.eqtype_as_type Prims.unit -> Prims.PURE a)
-> FStar.MST.repr a
state
rel
(fun _ -> wp (fun _ -> Prims.l_True))
(fun s0 x s1 -> wp (fun _ -> Prims.l_True) /\ ~(wp ... | {
"end_col": 9,
"end_line": 189,
"start_col": 2,
"start_line": 186
} |
Prims.Tot | val bind_div_mst
(a b: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(req: (a -> pre_t state))
(ens: (a -> post_t state b))
(f: (eqtype_as_type unit -> DIV a wp))
(g: (x: a -> repr b state rel (req x) (ens x)))
: repr b
state
rel
(f... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let bind_div_mst (a:Type) (b:Type)
(wp:pure_wp a)
(state:Type u#2) (rel:P.preorder state) (req:a -> pre_t state) (ens:a -> post_t state b)
(f:eqtype_as_type unit -> DIV a wp) (g:(x:a -> repr b state rel (req x) (ens x)))
: repr b state rel
(fun s0 -> wp (fun _ -> True) /\ (forall x. req x s0))
(fun s0 y s... | val bind_div_mst
(a b: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(req: (a -> pre_t state))
(ens: (a -> post_t state b))
(f: (eqtype_as_type unit -> DIV a wp))
(g: (x: a -> repr b state rel (req x) (ens x)))
: repr b
state
rel
(f... | false | null | false | elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
(g x) s0 | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [
"total"
] | [
"Prims.pure_wp",
"FStar.Preorder.preorder",
"FStar.MST.pre_t",
"FStar.MST.post_t",
"FStar.Pervasives.eqtype_as_type",
"Prims.unit",
"FStar.MST.repr",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"Prims.l_and",
"Prims.l_True",
"Prims.l_Forall",
"Prims.l_... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 bind_div_mst
(a b: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(req: (a -> pre_t state))
(ens: (a -> post_t state b))
(f: (eqtype_as_type unit -> DIV a wp))
(g: (x: a -> repr b state rel (req x) (ens x)))
: repr b
state
rel
(f... | [] | FStar.MST.bind_div_mst | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
b: Type ->
wp: Prims.pure_wp a ->
state: Type ->
rel: FStar.Preorder.preorder state ->
req: (_: a -> FStar.MST.pre_t state) ->
ens: (_: a -> FStar.MST.post_t state b) ->
f: (_: FStar.Pervasives.eqtype_as_type Prims.unit -> FStar.Pervasives.DIV a) ->
g: (x: a -> FStar.MST.... | {
"end_col": 10,
"end_line": 220,
"start_col": 2,
"start_line": 217
} |
Prims.Tot | val bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b s... | val bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
... | false | null | false | fun s0 ->
let x, s1 = f s0 in
(g x) s1 | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [
"total"
] | [
"FStar.Preorder.preorder",
"FStar.MST.pre_t",
"FStar.MST.post_t",
"FStar.MST.repr",
"FStar.Pervasives.Native.tuple2",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_Exists"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
... | [] | FStar.MST.bind | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
b: Type ->
state: Type ->
rel: FStar.Preorder.preorder state ->
req_f: FStar.MST.pre_t state ->
ens_f: FStar.MST.post_t state a ->
req_g: (_: a -> FStar.MST.pre_t state) ->
ens_g: (_: a -> FStar.MST.post_t state b) ->
f: FStar.MST.repr a state rel req_f ens_f ->
g: (x... | {
"end_col": 12,
"end_line": 67,
"start_col": 2,
"start_line": 65
} |
FStar.MST.MSTATE | val mst_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATE unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full... | false | let mst_assert (#state:Type u#2) (#rel:P.preorder state) (p:Type)
: MSTATE unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1)
=
assert p | val mst_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATE unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1)
let mst_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATE unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) = | true | null | false | assert p | {
"checked_file": "FStar.MST.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.MSTTotal.fst.checked",
"FStar.Monotonic.Pure.fst.checked"
... | [] | [
"FStar.Preorder.preorder",
"Prims._assert",
"Prims.unit",
"Prims.l_and",
"Prims.eq2"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | FStar.MST.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 mst_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATE unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) | [] | FStar.MST.mst_assert | {
"file_name": "ulib/experimental/FStar.MST.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: Type0 -> FStar.MST.MSTATE Prims.unit | {
"end_col": 10,
"end_line": 238,
"start_col": 2,
"start_line": 238
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"f... | false | let ctr (r:ref int) = prev:erased int -> SteelT (y:int{y == prev + 1}) (repr r prev) (repr r) | let ctr (r: ref int) = | false | null | false | prev: erased int -> SteelT (y: int{y == prev + 1}) (repr r prev) (repr r) | {
"checked_file": "Steel.Closure.fst.checked",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
... | [
"total"
] | [
"Steel.Reference.ref",
"Prims.int",
"FStar.Ghost.erased",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Ghost.reveal",
"Steel.Closure.repr"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.Closure.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 ctr : r: Steel.Reference.ref Prims.int -> Type0 | [] | Steel.Closure.ctr | {
"file_name": "lib/steel/Steel.Closure.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.Reference.ref Prims.int -> Type0 | {
"end_col": 94,
"end_line": 28,
"start_col": 22,
"start_line": 28
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"f... | false | let repr (r:ref int) (x:int) = pts_to r full_perm (hide x) | let repr (r: ref int) (x: int) = | false | null | false | pts_to r full_perm (hide x) | {
"checked_file": "Steel.Closure.fst.checked",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
... | [
"total"
] | [
"Steel.Reference.ref",
"Prims.int",
"Steel.Reference.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.Closure.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 repr : r: Steel.Reference.ref Prims.int -> x: Prims.int -> Steel.Effect.Common.vprop | [] | Steel.Closure.repr | {
"file_name": "lib/steel/Steel.Closure.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.Reference.ref Prims.int -> x: Prims.int -> Steel.Effect.Common.vprop | {
"end_col": 58,
"end_line": 26,
"start_col": 31,
"start_line": 26
} | |
Steel.Effect.SteelT | val new_counter (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0) | [
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,... | false | let new_counter = new_counter' | val new_counter (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0)
let new_counter = | true | null | false | new_counter' | {
"checked_file": "Steel.Closure.fst.checked",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
... | [] | [
"Steel.Closure.new_counter'"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Closure.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 new_counter (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0) | [] | Steel.Closure.new_counter | {
"file_name": "lib/steel/Steel.Closure.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | u7: Prims.unit -> Steel.Effect.SteelT Steel.Closure.ctr_t | {
"end_col": 30,
"end_line": 47,
"start_col": 18,
"start_line": 47
} |
Steel.Effect.SteelT | val next (r: ref int) (prev: erased int) : SteelT (y: int{y == prev + 1}) (repr r prev) (repr r) | [
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"f... | false | let next (r:ref int) (prev:erased int)
: SteelT (y:int{y == prev + 1}) (repr r prev) (repr r)
= let v = read_pt r in
let (x:int { x == prev + 1 }) = v + 1 in
write_pt r x;
x | val next (r: ref int) (prev: erased int) : SteelT (y: int{y == prev + 1}) (repr r prev) (repr r)
let next (r: ref int) (prev: erased int) : SteelT (y: int{y == prev + 1}) (repr r prev) (repr r) = | true | null | false | let v = read_pt r in
let x:x: int{x == prev + 1} = v + 1 in
write_pt r x;
x | {
"checked_file": "Steel.Closure.fst.checked",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
... | [] | [
"Steel.Reference.ref",
"Prims.int",
"FStar.Ghost.erased",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Ghost.reveal",
"Prims.unit",
"Steel.Reference.write_pt",
"FStar.Ghost.hide",
"Steel.Reference.read_pt",
"Steel.FractionalPermission.full_perm",
"Steel.Closure.repr"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Closure.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 next (r: ref int) (prev: erased int) : SteelT (y: int{y == prev + 1}) (repr r prev) (repr r) | [] | Steel.Closure.next | {
"file_name": "lib/steel/Steel.Closure.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.Reference.ref Prims.int -> prev: FStar.Ghost.erased Prims.int
-> Steel.Effect.SteelT (y: Prims.int{y == FStar.Ghost.reveal prev + 1}) | {
"end_col": 5,
"end_line": 35,
"start_col": 3,
"start_line": 32
} |
Steel.Effect.SteelT | val new_counter' (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0) | [
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"f... | false | let new_counter' () =
let x = alloc_pt 0 in
let f : ctr x = next x in
let res : ctr_t = (| repr x, f |) in
rewrite_slprop (repr x 0) (dfst res 0) (fun _ -> ());
return res | val new_counter' (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0)
let new_counter' () = | true | null | false | let x = alloc_pt 0 in
let f:ctr x = next x in
let res:ctr_t = (| repr x, f |) in
rewrite_slprop (repr x 0) (dfst res 0) (fun _ -> ());
return res | {
"checked_file": "Steel.Closure.fst.checked",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
... | [] | [
"Prims.unit",
"Steel.Effect.Atomic.return",
"Steel.Closure.ctr_t",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"FStar.Pervasives.dfst",
"Prims.int",
"Steel.Effect.Common.vprop",
"FStar.Ghost.erased",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Ghost.reveal",
... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Closure.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 new_counter' (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0) | [] | Steel.Closure.new_counter' | {
"file_name": "lib/steel/Steel.Closure.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | u6: Prims.unit -> Steel.Effect.SteelT Steel.Closure.ctr_t | {
"end_col": 12,
"end_line": 45,
"start_col": 21,
"start_line": 40
} |
FStar.Pervasives.Lemma | val lemma_ab_lt_cd (a b c d:pos) : Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_ab_lt_cd a b c d =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c | val lemma_ab_lt_cd (a b c d:pos) : Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let lemma_ab_lt_cd a b c d = | false | null | true | Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.pos",
"FStar.Math.Lemmas.lemma_mult_lt_right",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_lt_left"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_ab_lt_cd (a b c d:pos) : Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d) | [] | Hacl.Spec.K256.MathLemmas.lemma_ab_lt_cd | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.pos -> b: Prims.pos -> c: Prims.pos -> d: Prims.pos
-> FStar.Pervasives.Lemma (requires a < c /\ b < d) (ensures a * b < c * d) | {
"end_col": 39,
"end_line": 45,
"start_col": 2,
"start_line": 44
} |
FStar.Pervasives.Lemma | val lemma_ab_le_cd (a b c d:nat) : Lemma
(requires a <= c /\ b <= d)
(ensures a * b <= c * d) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_ab_le_cd a b c d =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_right d a c | val lemma_ab_le_cd (a b c d:nat) : Lemma
(requires a <= c /\ b <= d)
(ensures a * b <= c * d)
let lemma_ab_le_cd a b c d = | false | null | true | Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_right d a c | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_le_left"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_ab_le_cd (a b c d:nat) : Lemma
(requires a <= c /\ b <= d)
(ensures a * b <= c * d) | [] | Hacl.Spec.K256.MathLemmas.lemma_ab_le_cd | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.nat -> b: Prims.nat -> c: Prims.nat -> d: Prims.nat
-> FStar.Pervasives.Lemma (requires a <= c /\ b <= d) (ensures a * b <= c * d) | {
"end_col": 39,
"end_line": 37,
"start_col": 2,
"start_line": 36
} |
FStar.Pervasives.Lemma | val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
} | val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c = | false | null | true | calc ( == ) {
(a * b) * c;
( == ) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
( == ) { Math.Lemmas.swap_mul b c }
a * (c * b);
( == ) { Math.Lemmas.paren_mul_right a c b }
(a * c) * b;
} | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.paren_mul_right",
"Prims.squash",
"FStar.Math.Lemmas.swap_... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b) | false | false | Hacl.Spec.K256.MathLemmas.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_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b) | [] | Hacl.Spec.K256.MathLemmas.lemma_swap_mul3 | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int -> c: Prims.int
-> FStar.Pervasives.Lemma (ensures (a * b) * c == (a * c) * b) | {
"end_col": 3,
"end_line": 17,
"start_col": 2,
"start_line": 9
} |
FStar.Pervasives.Lemma | val lemma_mod_sub_distr (a b:int) (n:pos) : Lemma ((a - b) % n = (a % n - b % n) % n) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_mod_sub_distr a b n =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n | val lemma_mod_sub_distr (a b:int) (n:pos) : Lemma ((a - b) % n = (a % n - b % n) % n)
let lemma_mod_sub_distr a b n = | false | null | true | Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.pos",
"FStar.Math.Lemmas.lemma_mod_sub_distr",
"Prims.op_Modulus",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"Prims.op_Minus"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_mod_sub_distr (a b:int) (n:pos) : Lemma ((a - b) % n = (a % n - b % n) % n) | [] | Hacl.Spec.K256.MathLemmas.lemma_mod_sub_distr | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int -> n: Prims.pos
-> FStar.Pervasives.Lemma (ensures (a - b) % n = (a % n - b % n) % n) | {
"end_col": 45,
"end_line": 29,
"start_col": 2,
"start_line": 28
} |
FStar.Pervasives.Lemma | val lemma_mod_mul_distr (a b:int) (n:pos) : Lemma (a * b % n = (a % n) * (b % n) % n) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_mod_mul_distr a b n =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (a % n) b n | val lemma_mod_mul_distr (a b:int) (n:pos) : Lemma (a * b % n = (a % n) * (b % n) % n)
let lemma_mod_mul_distr a b n = | false | null | true | Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (a % n) b n | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.pos",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Prims.op_Modulus",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_mod_mul_distr (a b:int) (n:pos) : Lemma (a * b % n = (a % n) * (b % n) % n) | [] | Hacl.Spec.K256.MathLemmas.lemma_mod_mul_distr | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int -> n: Prims.pos
-> FStar.Pervasives.Lemma (ensures a * b % n = (a % n) * (b % n) % n) | {
"end_col": 47,
"end_line": 23,
"start_col": 2,
"start_line": 22
} |
FStar.Pervasives.Lemma | val lemma_a_plus_b_pow2_mod2 (a b:int) (c:pos) : Lemma ((a + b * pow2 c) % 2 = a % 2) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_a_plus_b_pow2_mod2 a b c =
assert_norm (pow2 1 = 2);
Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 c) 2;
Math.Lemmas.pow2_multiplication_modulo_lemma_1 b 1 c | val lemma_a_plus_b_pow2_mod2 (a b:int) (c:pos) : Lemma ((a + b * pow2 c) % 2 = a % 2)
let lemma_a_plus_b_pow2_mod2 a b c = | false | null | true | assert_norm (pow2 1 = 2);
Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 c) 2;
Math.Lemmas.pow2_multiplication_modulo_lemma_1 b 1 c | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.pos",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"FStar.Mul.op_Star",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_a_plus_b_pow2_mod2 (a b:int) (c:pos) : Lemma ((a + b * pow2 c) % 2 = a % 2) | [] | Hacl.Spec.K256.MathLemmas.lemma_a_plus_b_pow2_mod2 | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int -> c: Prims.pos
-> FStar.Pervasives.Lemma (ensures (a + b * Prims.pow2 c) % 2 = a % 2) | {
"end_col": 54,
"end_line": 130,
"start_col": 2,
"start_line": 128
} |
FStar.Pervasives.Lemma | val lemma_distr_eucl (a b:int) : Lemma ((a / pow2 52 + b) * pow2 52 + a % pow2 52 = a + b * pow2 52) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr_eucl a b = lemma_distr_eucl_mul_add 1 a b (pow2 52) | val lemma_distr_eucl (a b:int) : Lemma ((a / pow2 52 + b) * pow2 52 + a % pow2 52 = a + b * pow2 52)
let lemma_distr_eucl a b = | false | null | true | lemma_distr_eucl_mul_add 1 a b (pow2 52) | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Hacl.Spec.K256.MathLemmas.lemma_distr_eucl_mul_add",
"Prims.pow2",
"Prims.unit"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr_eucl (a b:int) : Lemma ((a / pow2 52 + b) * pow2 52 + a % pow2 52 = a + b * pow2 52) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr_eucl | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int
-> FStar.Pervasives.Lemma
(ensures (a / Prims.pow2 52 + b) * Prims.pow2 52 + a % Prims.pow2 52 = a + b * Prims.pow2 52) | {
"end_col": 67,
"end_line": 123,
"start_col": 27,
"start_line": 123
} |
FStar.Pervasives.Lemma | val lemma_bound_mul64_wide (ma mb:nat) (mma mmb:nat) (a b:nat) : Lemma
(requires a <= ma * mma /\ b <= mb * mmb)
(ensures a * b <= ma * mb * (mma * mmb)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_bound_mul64_wide ma mb mma mmb a b =
calc (<=) {
a * b;
(<=) { lemma_ab_le_cd a b (ma * mma) (mb * mmb) }
(ma * mma) * (mb * mmb);
(==) { Math.Lemmas.paren_mul_right ma mma (mb * mmb) }
ma * (mma * (mb * mmb));
(==) {
Math.Lemmas.paren_mul_right mma mb mmb;
Math.Lemmas.sw... | val lemma_bound_mul64_wide (ma mb:nat) (mma mmb:nat) (a b:nat) : Lemma
(requires a <= ma * mma /\ b <= mb * mmb)
(ensures a * b <= ma * mb * (mma * mmb))
let lemma_bound_mul64_wide ma mb mma mmb a b = | false | null | true | calc ( <= ) {
a * b;
( <= ) { lemma_ab_le_cd a b (ma * mma) (mb * mmb) }
(ma * mma) * (mb * mmb);
( == ) { Math.Lemmas.paren_mul_right ma mma (mb * mmb) }
ma * (mma * (mb * mmb));
( == ) { (Math.Lemmas.paren_mul_right mma mb mmb;
Math.Lemmas.swap_mul mma mb;
Math.Lemmas.paren_mul_right mb mma mmb) }... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.eq2",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.K256.MathL... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_bound_mul64_wide (ma mb:nat) (mma mmb:nat) (a b:nat) : Lemma
(requires a <= ma * mma /\ b <= mb * mmb)
(ensures a * b <= ma * mb * (mma * mmb)) | [] | Hacl.Spec.K256.MathLemmas.lemma_bound_mul64_wide | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ma: Prims.nat -> mb: Prims.nat -> mma: Prims.nat -> mmb: Prims.nat -> a: Prims.nat -> b: Prims.nat
-> FStar.Pervasives.Lemma (requires a <= ma * mma /\ b <= mb * mmb)
(ensures a * b <= (ma * mb) * (mma * mmb)) | {
"end_col": 3,
"end_line": 66,
"start_col": 2,
"start_line": 53
} |
FStar.Pervasives.Lemma | val lemma_distr_pow_pow (a:int) (b:nat) (c:int) (d e:nat) :
Lemma ((a * pow2 b + c * pow2 d) * pow2 e = a * pow2 (b + e) + c * pow2 (d + e)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr_pow_pow a b c d e =
calc (==) {
(a * pow2 b + c * pow2 d) * pow2 e;
(==) { lemma_distr_pow (a * pow2 b) c d e }
a * pow2 b * pow2 e + c * pow2 (d + e);
(==) { Math.Lemmas.paren_mul_right a (pow2 b) (pow2 e); Math.Lemmas.pow2_plus b e }
a * pow2 (b + e) + c * pow2 (d + e);
} | val lemma_distr_pow_pow (a:int) (b:nat) (c:int) (d e:nat) :
Lemma ((a * pow2 b + c * pow2 d) * pow2 e = a * pow2 (b + e) + c * pow2 (d + e))
let lemma_distr_pow_pow a b c d e = | false | null | true | calc ( == ) {
(a * pow2 b + c * pow2 d) * pow2 e;
( == ) { lemma_distr_pow (a * pow2 b) c d e }
(a * pow2 b) * pow2 e + c * pow2 (d + e);
( == ) { (Math.Lemmas.paren_mul_right a (pow2 b) (pow2 e);
Math.Lemmas.pow2_plus b e) }
a * pow2 (b + e) + c * pow2 (d + e);
} | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.K256.MathLemmas.... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr_pow_pow (a:int) (b:nat) (c:int) (d e:nat) :
Lemma ((a * pow2 b + c * pow2 d) * pow2 e = a * pow2 (b + e) + c * pow2 (d + e)) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr_pow_pow | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.nat -> c: Prims.int -> d: Prims.nat -> e: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(a * Prims.pow2 b + c * Prims.pow2 d) * Prims.pow2 e =
a * Prims.pow2 (b + e) + c * Prims.pow2 (d + e)) | {
"end_col": 3,
"end_line": 89,
"start_col": 2,
"start_line": 83
} |
FStar.Pervasives.Lemma | val lemma_distr_pow (a b:int) (c d:nat) : Lemma ((a + b * pow2 c) * pow2 d = a * pow2 d + b * pow2 (c + d)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr_pow a b c d =
calc (==) {
(a + b * pow2 c) * pow2 d;
(==) { Math.Lemmas.distributivity_add_left a (b * pow2 c) (pow2 d) }
a * pow2 d + b * pow2 c * pow2 d;
(==) { Math.Lemmas.paren_mul_right b (pow2 c) (pow2 d); Math.Lemmas.pow2_plus c d }
a * pow2 d + b * pow2 (c + d);
} | val lemma_distr_pow (a b:int) (c d:nat) : Lemma ((a + b * pow2 c) * pow2 d = a * pow2 d + b * pow2 (c + d))
let lemma_distr_pow a b c d = | false | null | true | calc ( == ) {
(a + b * pow2 c) * pow2 d;
( == ) { Math.Lemmas.distributivity_add_left a (b * pow2 c) (pow2 d) }
a * pow2 d + (b * pow2 c) * pow2 d;
( == ) { (Math.Lemmas.paren_mul_right b (pow2 c) (pow2 d);
Math.Lemmas.pow2_plus c d) }
a * pow2 d + b * pow2 (c + d);
} | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.distribu... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr_pow (a b:int) (c d:nat) : Lemma ((a + b * pow2 c) * pow2 d = a * pow2 d + b * pow2 (c + d)) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr_pow | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int -> c: Prims.nat -> d: Prims.nat
-> FStar.Pervasives.Lemma
(ensures (a + b * Prims.pow2 c) * Prims.pow2 d = a * Prims.pow2 d + b * Prims.pow2 (c + d)) | {
"end_col": 3,
"end_line": 77,
"start_col": 2,
"start_line": 71
} |
FStar.Pervasives.Lemma | val lemma_a_mod_b_mul_c_mod_d (a b c d:nat) : Lemma
(requires c <= d /\ b <= d - c)
(ensures (a % pow2 b) * pow2 c % pow2 d = (a % pow2 b) * pow2 c) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_a_mod_b_mul_c_mod_d a b c d =
Math.Lemmas.pow2_multiplication_modulo_lemma_2 (a % pow2 b) d c;
Math.Lemmas.pow2_modulo_modulo_lemma_2 a (d - c) b | val lemma_a_mod_b_mul_c_mod_d (a b c d:nat) : Lemma
(requires c <= d /\ b <= d - c)
(ensures (a % pow2 b) * pow2 c % pow2 d = (a % pow2 b) * pow2 c)
let lemma_a_mod_b_mul_c_mod_d a b c d = | false | null | true | Math.Lemmas.pow2_multiplication_modulo_lemma_2 (a % pow2 b) d c;
Math.Lemmas.pow2_modulo_modulo_lemma_2 a (d - c) b | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_2",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"Prims.op_Modulus",
"Prims.pow2"
] | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_a_mod_b_mul_c_mod_d (a b c d:nat) : Lemma
(requires c <= d /\ b <= d - c)
(ensures (a % pow2 b) * pow2 c % pow2 d = (a % pow2 b) * pow2 c) | [] | Hacl.Spec.K256.MathLemmas.lemma_a_mod_b_mul_c_mod_d | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.nat -> b: Prims.nat -> c: Prims.nat -> d: Prims.nat
-> FStar.Pervasives.Lemma (requires c <= d /\ b <= d - c)
(ensures (a % Prims.pow2 b) * Prims.pow2 c % Prims.pow2 d = (a % Prims.pow2 b) * Prims.pow2 c) | {
"end_col": 52,
"end_line": 274,
"start_col": 2,
"start_line": 273
} |
FStar.Pervasives.Lemma | val lemma_a_div_b_plus_c_mod_d_mul_e (a b c d e:nat) : Lemma
(requires a / pow2 b < pow2 e)
(ensures a / pow2 b + c % pow2 d * pow2 e < pow2 (d + e)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_a_div_b_plus_c_mod_d_mul_e a b c d e =
let t_r = c % pow2 d * pow2 e in
Math.Lemmas.lemma_mult_le_right (pow2 e) (c % pow2 d) (pow2 d - 1);
assert (t_r <= (pow2 d - 1) * pow2 e);
assert (t_r <= pow2 d * pow2 e - pow2 e);
Math.Lemmas.pow2_plus d e;
assert (t_r <= pow2 (d + e) - pow2 e);
assert (a... | val lemma_a_div_b_plus_c_mod_d_mul_e (a b c d e:nat) : Lemma
(requires a / pow2 b < pow2 e)
(ensures a / pow2 b + c % pow2 d * pow2 e < pow2 (d + e))
let lemma_a_div_b_plus_c_mod_d_mul_e a b c d e = | false | null | true | let t_r = (c % pow2 d) * pow2 e in
Math.Lemmas.lemma_mult_le_right (pow2 e) (c % pow2 d) (pow2 d - 1);
assert (t_r <= (pow2 d - 1) * pow2 e);
assert (t_r <= pow2 d * pow2 e - pow2 e);
Math.Lemmas.pow2_plus d e;
assert (t_r <= pow2 (d + e) - pow2 e);
assert (a / pow2 b + (c % pow2 d) * pow2 e < pow2 (d + e)) | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.unit",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.lemma_mult_le... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_a_div_b_plus_c_mod_d_mul_e (a b c d e:nat) : Lemma
(requires a / pow2 b < pow2 e)
(ensures a / pow2 b + c % pow2 d * pow2 e < pow2 (d + e)) | [] | Hacl.Spec.K256.MathLemmas.lemma_a_div_b_plus_c_mod_d_mul_e | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.nat -> b: Prims.nat -> c: Prims.nat -> d: Prims.nat -> e: Prims.nat
-> FStar.Pervasives.Lemma (requires a / Prims.pow2 b < Prims.pow2 e)
(ensures a / Prims.pow2 b + (c % Prims.pow2 d) * Prims.pow2 e < Prims.pow2 (d + e)) | {
"end_col": 58,
"end_line": 265,
"start_col": 48,
"start_line": 258
} |
FStar.Pervasives.Lemma | val lemma_distr5 (a0 a1 a2 a3 a4 b:int) : Lemma
((a0 + a1 + a2 + a3 + a4) * b = a0 * b + a1 * b + a2 * b + a3 * b + a4 * b) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr5 a0 a1 a2 a3 a4 b =
calc (==) {
(a0 + a1 + a2 + a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a0 (a1 + a2 + a3 + a4) b }
a0 * b + (a1 + a2 + a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a1 (a2 + a3 + a4) b }
a0 * b + a1 * b + (a2 + a3 + a4) * b;
(==) { Ma... | val lemma_distr5 (a0 a1 a2 a3 a4 b:int) : Lemma
((a0 + a1 + a2 + a3 + a4) * b = a0 * b + a1 * b + a2 * b + a3 * b + a4 * b)
let lemma_distr5 a0 a1 a2 a3 a4 b = | false | null | true | calc ( == ) {
(a0 + a1 + a2 + a3 + a4) * b;
( == ) { Math.Lemmas.distributivity_add_left a0 (a1 + a2 + a3 + a4) b }
a0 * b + (a1 + a2 + a3 + a4) * b;
( == ) { Math.Lemmas.distributivity_add_left a1 (a2 + a3 + a4) b }
a0 * b + a1 * b + (a2 + a3 + a4) * b;
( == ) { Math.Lemmas.distributivity_add_left a2 (a3 +... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.distributivity_add_left",
"Prims.squa... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr5 (a0 a1 a2 a3 a4 b:int) : Lemma
((a0 + a1 + a2 + a3 + a4) * b = a0 * b + a1 * b + a2 * b + a3 * b + a4 * b) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr5 | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a0: Prims.int -> a1: Prims.int -> a2: Prims.int -> a3: Prims.int -> a4: Prims.int -> b: Prims.int
-> FStar.Pervasives.Lemma
(ensures (a0 + a1 + a2 + a3 + a4) * b = a0 * b + a1 * b + a2 * b + a3 * b + a4 * b) | {
"end_col": 3,
"end_line": 183,
"start_col": 2,
"start_line": 173
} |
FStar.Pervasives.Lemma | val lemma_distr_eucl_mul (r a:int) (b:pos) : Lemma (r * (a % b) + r * (a / b) * b = r * a) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr_eucl_mul r a b =
calc (==) {
r * (a % b) + r * (a / b) * b;
(==) { Math.Lemmas.paren_mul_right r (a / b) b }
r * (a % b) + r * ((a / b) * b);
(==) { Math.Lemmas.distributivity_add_right r (a % b) (a / b * b) }
r * (a % b + a / b * b);
(==) { Math.Lemmas.euclidean_division_defin... | val lemma_distr_eucl_mul (r a:int) (b:pos) : Lemma (r * (a % b) + r * (a / b) * b = r * a)
let lemma_distr_eucl_mul r a b = | false | null | true | calc ( == ) {
r * (a % b) + (r * (a / b)) * b;
( == ) { Math.Lemmas.paren_mul_right r (a / b) b }
r * (a % b) + r * ((a / b) * b);
( == ) { Math.Lemmas.distributivity_add_right r (a % b) ((a / b) * b) }
r * (a % b + (a / b) * b);
( == ) { Math.Lemmas.euclidean_division_definition a b }
r * a;
} | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr_eucl_mul (r a:int) (b:pos) : Lemma (r * (a % b) + r * (a / b) * b = r * a) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr_eucl_mul | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Prims.int -> a: Prims.int -> b: Prims.pos
-> FStar.Pervasives.Lemma (ensures r * (a % b) + (r * (a / b)) * b = r * a) | {
"end_col": 3,
"end_line": 102,
"start_col": 2,
"start_line": 94
} |
FStar.Pervasives.Lemma | val lemma_a_mul_c_plus_d_mod_e_mul_f_g (a b c d f g:nat) : Lemma
(requires c == g - b)
(ensures
a % pow2 b * pow2 c + (a / pow2 b + d * pow2 f) * pow2 g ==
a * pow2 c + d * pow2 (f + g)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_a_mul_c_plus_d_mod_e_mul_f_g a b c d f g =
calc (==) {
a % pow2 b * pow2 c + (a / pow2 b + d * pow2 f) * pow2 g;
(==) { lemma_distr_pow (a / pow2 b) d f g }
a % pow2 b * pow2 c + (a / pow2 b) * pow2 (c + b) + d * pow2 (f + g);
(==) { lemma_distr_pow (a % pow2 b) (a / pow2 b) b c }
(a % p... | val lemma_a_mul_c_plus_d_mod_e_mul_f_g (a b c d f g:nat) : Lemma
(requires c == g - b)
(ensures
a % pow2 b * pow2 c + (a / pow2 b + d * pow2 f) * pow2 g ==
a * pow2 c + d * pow2 (f + g))
let lemma_a_mul_c_plus_d_mod_e_mul_f_g a b c d f g = | false | null | true | calc ( == ) {
(a % pow2 b) * pow2 c + (a / pow2 b + d * pow2 f) * pow2 g;
( == ) { lemma_distr_pow (a / pow2 b) d f g }
(a % pow2 b) * pow2 c + (a / pow2 b) * pow2 (c + b) + d * pow2 (f + g);
( == ) { lemma_distr_pow (a % pow2 b) (a / pow2 b) b c }
(a % pow2 b + (a / pow2 b) * pow2 b) * pow2 c + d * pow2 (f +... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.pow2",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.C... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_a_mul_c_plus_d_mod_e_mul_f_g (a b c d f g:nat) : Lemma
(requires c == g - b)
(ensures
a % pow2 b * pow2 c + (a / pow2 b + d * pow2 f) * pow2 g ==
a * pow2 c + d * pow2 (f + g)) | [] | Hacl.Spec.K256.MathLemmas.lemma_a_mul_c_plus_d_mod_e_mul_f_g | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.nat -> b: Prims.nat -> c: Prims.nat -> d: Prims.nat -> f: Prims.nat -> g: Prims.nat
-> FStar.Pervasives.Lemma (requires c == g - b)
(ensures
(a % Prims.pow2 b) * Prims.pow2 c + (a / Prims.pow2 b + d * Prims.pow2 f) * Prims.pow2 g ==
a * Prims.pow2 c + d * Prims.pow2 (f + g)) | {
"end_col": 3,
"end_line": 292,
"start_col": 2,
"start_line": 284
} |
FStar.Pervasives.Lemma | val lemma_a_mod_52_mul_b (a b:nat) :
Lemma ((a % pow2 52) * pow2 b = a * pow2 b - a / pow2 52 * pow2 (b + 52)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_a_mod_52_mul_b a b =
calc (==) {
(a % pow2 52) * pow2 b;
(==) { Math.Lemmas.euclidean_division_definition a (pow2 52) }
(a - a / pow2 52 * pow2 52) * pow2 b;
(==) { Math.Lemmas.distributivity_sub_left a (a / pow2 52 * pow2 52) (pow2 b) }
a * pow2 b - a / pow2 52 * pow2 52 * pow2 b;
(... | val lemma_a_mod_52_mul_b (a b:nat) :
Lemma ((a % pow2 52) * pow2 b = a * pow2 b - a / pow2 52 * pow2 (b + 52))
let lemma_a_mod_52_mul_b a b = | false | null | true | calc ( == ) {
(a % pow2 52) * pow2 b;
( == ) { Math.Lemmas.euclidean_division_definition a (pow2 52) }
(a - (a / pow2 52) * pow2 52) * pow2 b;
( == ) { Math.Lemmas.distributivity_sub_left a ((a / pow2 52) * pow2 52) (pow2 b) }
a * pow2 b - ((a / pow2 52) * pow2 52) * pow2 b;
( == ) { (Math.Lemmas.paren_mul_... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.op_Division",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.C... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_a_mod_52_mul_b (a b:nat) :
Lemma ((a % pow2 52) * pow2 b = a * pow2 b - a / pow2 52 * pow2 (b + 52)) | [] | Hacl.Spec.K256.MathLemmas.lemma_a_mod_52_mul_b | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.nat -> b: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(a % Prims.pow2 52) * Prims.pow2 b =
a * Prims.pow2 b - (a / Prims.pow2 52) * Prims.pow2 (b + 52)) | {
"end_col": 3,
"end_line": 307,
"start_col": 2,
"start_line": 299
} |
FStar.Pervasives.Lemma | val lemma_distr_eucl_mul_add (r a c:int) (b:pos) : Lemma (r * (a % b) + r * (a / b + c) * b = r * a + r * c * b) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr_eucl_mul_add r a c b =
calc (==) {
r * (a % b) + r * (a / b + c) * b;
(==) { Math.Lemmas.paren_mul_right r (a / b + c) b }
r * (a % b) + r * ((a / b + c) * b);
(==) { Math.Lemmas.distributivity_add_left (a / b) c b }
r * (a % b) + r * ((a / b * b) + c * b);
(==) { Math.Lemmas.d... | val lemma_distr_eucl_mul_add (r a c:int) (b:pos) : Lemma (r * (a % b) + r * (a / b + c) * b = r * a + r * c * b)
let lemma_distr_eucl_mul_add r a c b = | false | null | true | calc ( == ) {
r * (a % b) + (r * (a / b + c)) * b;
( == ) { Math.Lemmas.paren_mul_right r (a / b + c) b }
r * (a % b) + r * ((a / b + c) * b);
( == ) { Math.Lemmas.distributivity_add_left (a / b) c b }
r * (a % b) + r * (((a / b) * b) + c * b);
( == ) { Math.Lemmas.distributivity_add_right r ((a / b) * b) (... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr_eucl_mul_add (r a c:int) (b:pos) : Lemma (r * (a % b) + r * (a / b + c) * b = r * a + r * c * b) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr_eucl_mul_add | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Prims.int -> a: Prims.int -> c: Prims.int -> b: Prims.pos
-> FStar.Pervasives.Lemma (ensures r * (a % b) + (r * (a / b + c)) * b = r * a + (r * c) * b) | {
"end_col": 3,
"end_line": 119,
"start_col": 2,
"start_line": 107
} |
FStar.Pervasives.Lemma | val lemma_as_nat_horner (r0 r1 r2 r3 r4:int) :
Lemma (r0 + r1 * pow2 52 + r2 * pow2 104 + r3 * pow2 156 + r4 * pow2 208 ==
(((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 52 + r1) * pow2 52 + r0) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_as_nat_horner r0 r1 r2 r3 r4 =
calc (==) {
(((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 52 + r1) * pow2 52 + r0;
(==) { lemma_distr_pow r1 ((r4 * pow2 52 + r3) * pow2 52 + r2) 52 52 }
((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r2 (r4 * pow2 52... | val lemma_as_nat_horner (r0 r1 r2 r3 r4:int) :
Lemma (r0 + r1 * pow2 52 + r2 * pow2 104 + r3 * pow2 156 + r4 * pow2 208 ==
(((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 52 + r1) * pow2 52 + r0)
let lemma_as_nat_horner r0 r1 r2 r3 r4 = | false | null | true | calc ( == ) {
(((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 52 + r1) * pow2 52 + r0;
( == ) { lemma_distr_pow r1 ((r4 * pow2 52 + r3) * pow2 52 + r2) 52 52 }
((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 104 + r1 * pow2 52 + r0;
( == ) { lemma_distr_pow r2 (r4 * pow2 52 + r3) 52 104 }
(r4 * pow2 52 + r3) * pow2 ... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.K256.MathLemmas.lemma_distr_pow... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_as_nat_horner (r0 r1 r2 r3 r4:int) :
Lemma (r0 + r1 * pow2 52 + r2 * pow2 104 + r3 * pow2 156 + r4 * pow2 208 ==
(((r4 * pow2 52 + r3) * pow2 52 + r2) * pow2 52 + r1) * pow2 52 + r0) | [] | Hacl.Spec.K256.MathLemmas.lemma_as_nat_horner | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r0: Prims.int -> r1: Prims.int -> r2: Prims.int -> r3: Prims.int -> r4: Prims.int
-> FStar.Pervasives.Lemma
(ensures
r0 + r1 * Prims.pow2 52 + r2 * Prims.pow2 104 + r3 * Prims.pow2 156 + r4 * Prims.pow2 208 ==
(((r4 * Prims.pow2 52 + r3) * Prims.pow2 52 + r2) * Prims.pow2 52 + r1) * Prims.pow2 52 + r0... | {
"end_col": 3,
"end_line": 166,
"start_col": 2,
"start_line": 158
} |
FStar.Pervasives.Lemma | val lemma_as_nat64_horner (r0 r1 r2 r3:int) :
Lemma (r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192 ==
((r3 * pow2 64 + r2) * pow2 64 + r1) * pow2 64 + r0) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_as_nat64_horner r0 r1 r2 r3 =
calc (==) {
r0 + pow2 64 * (r1 + pow2 64 * (r2 + pow2 64 * r3));
(==) { Math.Lemmas.swap_mul (pow2 64) (r1 + pow2 64 * (r2 + pow2 64 * r3)) }
r0 + (r1 + pow2 64 * (r2 + pow2 64 * r3)) * pow2 64;
(==) { Math.Lemmas.swap_mul (pow2 64) (r2 + pow2 64 * r3) }
r0 ... | val lemma_as_nat64_horner (r0 r1 r2 r3:int) :
Lemma (r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192 ==
((r3 * pow2 64 + r2) * pow2 64 + r1) * pow2 64 + r0)
let lemma_as_nat64_horner r0 r1 r2 r3 = | false | null | true | calc ( == ) {
r0 + pow2 64 * (r1 + pow2 64 * (r2 + pow2 64 * r3));
( == ) { Math.Lemmas.swap_mul (pow2 64) (r1 + pow2 64 * (r2 + pow2 64 * r3)) }
r0 + (r1 + pow2 64 * (r2 + pow2 64 * r3)) * pow2 64;
( == ) { Math.Lemmas.swap_mul (pow2 64) (r2 + pow2 64 * r3) }
r0 + (r1 + (r2 + pow2 64 * r3) * pow2 64) * pow2 ... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.swap_mul",
"Prims.squ... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_as_nat64_horner (r0 r1 r2 r3:int) :
Lemma (r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192 ==
((r3 * pow2 64 + r2) * pow2 64 + r1) * pow2 64 + r0) | [] | Hacl.Spec.K256.MathLemmas.lemma_as_nat64_horner | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r0: Prims.int -> r1: Prims.int -> r2: Prims.int -> r3: Prims.int
-> FStar.Pervasives.Lemma
(ensures
r0 + r1 * Prims.pow2 64 + r2 * Prims.pow2 128 + r3 * Prims.pow2 192 ==
((r3 * Prims.pow2 64 + r2) * Prims.pow2 64 + r1) * Prims.pow2 64 + r0) | {
"end_col": 3,
"end_line": 150,
"start_col": 2,
"start_line": 138
} |
FStar.Pervasives.Lemma | val lemma_distr5_pow52_mul_pow (a b0 b1 b2 b3 b4: int) (p:nat) : Lemma
(a * pow2 p * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) =
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) +
a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr5_pow52_mul_pow a b0 b1 b2 b3 b4 p =
let b_sum = b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208 in
calc (==) {
a * pow2 p * b_sum;
(==) { lemma_swap_mul3 a (pow2 p) b_sum }
a * b_sum * pow2 p;
(==) { lemma_distr5_pow52 a b0 b1 b2 b3 b4 }
(a * b0 + a * b1 * pow2 ... | val lemma_distr5_pow52_mul_pow (a b0 b1 b2 b3 b4: int) (p:nat) : Lemma
(a * pow2 p * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) =
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) +
a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p))
let lemma_distr5_pow52_mul_pow a b0 b... | false | null | true | let b_sum = b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208 in
calc ( == ) {
(a * pow2 p) * b_sum;
( == ) { lemma_swap_mul3 a (pow2 p) b_sum }
(a * b_sum) * pow2 p;
( == ) { lemma_distr5_pow52 a b0 b1 b2 b3 b4 }
(a * b0 + (a * b1) * pow2 52 + (a * b2) * pow2 104 + (a * b3) * pow2 156 + (a * ... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.K256.MathLemmas.... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr5_pow52_mul_pow (a b0 b1 b2 b3 b4: int) (p:nat) : Lemma
(a * pow2 p * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) =
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) +
a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p)) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr5_pow52_mul_pow | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Prims.int ->
b0: Prims.int ->
b1: Prims.int ->
b2: Prims.int ->
b3: Prims.int ->
b4: Prims.int ->
p: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(a * Prims.pow2 p) *
(b0 + b1 * Prims.pow2 52 + b2 * Prims.pow2 104 + b3 * Prims.pow2 156 + b4 * Prims.pow2 208) =
(a ... | {
"end_col": 3,
"end_line": 223,
"start_col": 51,
"start_line": 207
} |
FStar.Pervasives.Lemma | val lemma_distr5_pow52 (a b0 b1 b2 b3 b4:int) : Lemma
(a * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) =
a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr5_pow52 a b0 b1 b2 b3 b4 =
calc (==) {
a * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208);
(==) { lemma_distr5 b0 (b1 * pow2 52) (b2 * pow2 104) (b3 * pow2 156) (b4 * pow2 208) a }
b0 * a + b1 * pow2 52 * a + b2 * pow2 104 * a + b3 * pow2 156 * a + b4 * pow2 208 * a;
... | val lemma_distr5_pow52 (a b0 b1 b2 b3 b4:int) : Lemma
(a * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) =
a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208)
let lemma_distr5_pow52 a b0 b1 b2 b3 b4 = | false | null | true | calc ( == ) {
a * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208);
( == ) { lemma_distr5 b0 (b1 * pow2 52) (b2 * pow2 104) (b3 * pow2 156) (b4 * pow2 208) a }
b0 * a + (b1 * pow2 52) * a + (b2 * pow2 104) * a + (b3 * pow2 156) * a + (b4 * pow2 208) * a;
( == ) { (lemma_swap_mul3 b1 (pow2 52)... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.K256.MathLemmas.lemma_distr5",
... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr5_pow52 (a b0 b1 b2 b3 b4:int) : Lemma
(a * (b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) =
a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) | [] | Hacl.Spec.K256.MathLemmas.lemma_distr5_pow52 | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b0: Prims.int -> b1: Prims.int -> b2: Prims.int -> b3: Prims.int -> b4: Prims.int
-> FStar.Pervasives.Lemma
(ensures
a *
(b0 + b1 * Prims.pow2 52 + b2 * Prims.pow2 104 + b3 * Prims.pow2 156 + b4 * Prims.pow2 208) =
a * b0 + (a * b1) * Prims.pow2 52 + (a * b2) * Prims.pow2 104 + (... | {
"end_col": 3,
"end_line": 199,
"start_col": 2,
"start_line": 191
} |
FStar.Pervasives.Lemma | val lemma_distr5_pow52_sub (a0 a1 a2 a3 a4 b0 b1 b2 b3 b4 c:int) : Lemma
((b0 * c - a0) + (b1 * c - a1) * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208 ==
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + ... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_distr5_pow52_sub a0 a1 a2 a3 a4 b0 b1 b2 b3 b4 c =
calc (==) {
(b0 * c - a0) + (b1 * c - a1) * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b1 * c) a1 (pow2 52) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * po... | val lemma_distr5_pow52_sub (a0 a1 a2 a3 a4 b0 b1 b2 b3 b4 c:int) : Lemma
((b0 * c - a0) + (b1 * c - a1) * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208 ==
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + ... | false | null | true | calc ( == ) {
(b0 * c - a0) + (b1 * c - a1) * pow2 52 + (b2 * c - a2) * pow2 104 + (b3 * c - a3) * pow2 156 +
(b4 * c - a4) * pow2 208;
( == ) { Math.Lemmas.distributivity_sub_left (b1 * c) a1 (pow2 52) }
c * b0 - a0 + (c * b1) * pow2 52 - a1 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 +
... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Addition",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemm... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_distr5_pow52_sub (a0 a1 a2 a3 a4 b0 b1 b2 b3 b4 c:int) : Lemma
((b0 * c - a0) + (b1 * c - a1) * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208 ==
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + ... | [] | Hacl.Spec.K256.MathLemmas.lemma_distr5_pow52_sub | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a0: Prims.int ->
a1: Prims.int ->
a2: Prims.int ->
a3: Prims.int ->
a4: Prims.int ->
b0: Prims.int ->
b1: Prims.int ->
b2: Prims.int ->
b3: Prims.int ->
b4: Prims.int ->
c: Prims.int
-> FStar.Pervasives.Lemma
(ensures
b0 * c - a0 + (b1 * c - a1) * Prims.pow2 52 +... | {
"end_col": 3,
"end_line": 251,
"start_col": 2,
"start_line": 233
} |
FStar.Pervasives.Lemma | val lemma_simplify_carry_round (t0 t1 t2 t3 t4:nat) : Lemma
(let a = t1 + t0 / pow2 52 in
let b = t2 + a / pow2 52 in
let c = t3 + b / pow2 52 in
let d = t4 + c / pow2 52 in
t0 % pow2 52 + (a % pow2 52) * pow2 52 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 + d * pow2 208 ==
t0 + t1 * pow2 52 + t2... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | false | let lemma_simplify_carry_round t0 t1 t2 t3 t4 =
let a = t1 + t0 / pow2 52 in
let b = t2 + a / pow2 52 in
let c = t3 + b / pow2 52 in
let d = t4 + c / pow2 52 in
calc (==) {
t0 % pow2 52 + (a % pow2 52) * pow2 52 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 + d * pow2 208;
(==) { lemma_a_... | val lemma_simplify_carry_round (t0 t1 t2 t3 t4:nat) : Lemma
(let a = t1 + t0 / pow2 52 in
let b = t2 + a / pow2 52 in
let c = t3 + b / pow2 52 in
let d = t4 + c / pow2 52 in
t0 % pow2 52 + (a % pow2 52) * pow2 52 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 + d * pow2 208 ==
t0 + t1 * pow2 52 + t2... | false | null | true | let a = t1 + t0 / pow2 52 in
let b = t2 + a / pow2 52 in
let c = t3 + b / pow2 52 in
let d = t4 + c / pow2 52 in
calc ( == ) {
t0 % pow2 52 + (a % pow2 52) * pow2 52 + (b % pow2 52) * pow2 104 + (c % pow2 52) * pow2 156 +
d * pow2 208;
( == ) { lemma_a_mod_52_mul_b a 52 }
t0 % pow2 52 + (t1 + t0 / pow2 52) * po... | {
"checked_file": "Hacl.Spec.K256.MathLemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.MathLemmas.fst"
... | [
"lemma"
] | [
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Prims.op_Modulus",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"Prims.op_Division",
"FStar.C... | [] | module Hacl.Spec.K256.MathLemmas
open FStar.Mul
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_swap_mul3 (a b c:int) : Lemma (a * b * c == a * c * b)
let lemma_swap_mul3 a b c =
calc (==) {
a * b * c;
(==) { Math.Lemmas.paren_mul_right a b c }
a * (b * c);
(==) { Math.Lemmas.swap_mul b c... | false | false | Hacl.Spec.K256.MathLemmas.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_simplify_carry_round (t0 t1 t2 t3 t4:nat) : Lemma
(let a = t1 + t0 / pow2 52 in
let b = t2 + a / pow2 52 in
let c = t3 + b / pow2 52 in
let d = t4 + c / pow2 52 in
t0 % pow2 52 + (a % pow2 52) * pow2 52 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 + d * pow2 208 ==
t0 + t1 * pow2 52 + t2... | [] | Hacl.Spec.K256.MathLemmas.lemma_simplify_carry_round | {
"file_name": "code/k256/Hacl.Spec.K256.MathLemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t0: Prims.nat -> t1: Prims.nat -> t2: Prims.nat -> t3: Prims.nat -> t4: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(let a = t1 + t0 / Prims.pow2 52 in
let b = t2 + a / Prims.pow2 52 in
let c = t3 + b / Prims.pow2 52 in
let d = t4 + c / Prims.pow2 52 in
t0 % Prims.pow2 52 + ... | {
"end_col": 3,
"end_line": 347,
"start_col": 47,
"start_line": 319
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
... | false | let point = lbuffer uint64 20ul | let point = | false | null | false | lbuffer uint64 20ul | {
"checked_file": "Hacl.Bignum25519.fsti.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl... | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Bignum25519
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
module BSeq = Lib.ByteSequence
module S51 = Hacl.Spec.Curve25519.Field51.Definition
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
... | false | true | Hacl.Bignum25519.fsti | {
"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 point : Type0 | [] | Hacl.Bignum25519.point | {
"file_name": "code/ed25519/Hacl.Bignum25519.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 31,
"end_line": 23,
"start_col": 12,
"start_line": 23
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
... | false | let felem = lbuffer uint64 5ul | let felem = | false | null | false | lbuffer uint64 5ul | {
"checked_file": "Hacl.Bignum25519.fsti.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl... | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Bignum25519
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
module BSeq = Lib.ByteSequence
module S51 = Hacl.Spec.Curve25519.Field51.Definition
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
... | false | true | Hacl.Bignum25519.fsti | {
"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 : Type0 | [] | Hacl.Bignum25519.felem | {
"file_name": "code/ed25519/Hacl.Bignum25519.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 30,
"end_line": 19,
"start_col": 12,
"start_line": 19
} | |
FStar.HyperStack.ST.Stack | val getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
... | false | let getz (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1)
= sub p 10ul 5ul | val getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1)
let getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) = | true | null | false | sub p 10ul 5ul | {
"checked_file": "Hacl.Bignum25519.fsti.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl... | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Bignum25519.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.gsub"
] | [] | module Hacl.Bignum25519
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
module BSeq = Lib.ByteSequence
module S51 = Hacl.Spec.Curve25519.Field51.Definition
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
... | false | false | Hacl.Bignum25519.fsti | {
"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 getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) | [] | Hacl.Bignum25519.getz | {
"file_name": "code/ed25519/Hacl.Bignum25519.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Hacl.Bignum25519.felem | {
"end_col": 18,
"end_line": 41,
"start_col": 4,
"start_line": 41
} |
FStar.HyperStack.ST.Stack | val gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
... | false | let gety (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1)
= sub p 5ul 5ul | val gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1)
let gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = | true | null | false | sub p 5ul 5ul | {
"checked_file": "Hacl.Bignum25519.fsti.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl... | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Bignum25519.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.gsub"
] | [] | module Hacl.Bignum25519
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
module BSeq = Lib.ByteSequence
module S51 = Hacl.Spec.Curve25519.Field51.Definition
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
... | false | false | Hacl.Bignum25519.fsti | {
"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 gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) | [] | Hacl.Bignum25519.gety | {
"file_name": "code/ed25519/Hacl.Bignum25519.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Hacl.Bignum25519.felem | {
"end_col": 17,
"end_line": 35,
"start_col": 4,
"start_line": 35
} |
FStar.HyperStack.ST.Stack | val gett (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 15ul 5ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
... | false | let gett (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 15ul 5ul /\ h0 == h1)
= sub p 15ul 5ul | val gett (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 15ul 5ul /\ h0 == h1)
let gett (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 15ul 5ul /\ h0 == h1) = | true | null | false | sub p 15ul 5ul | {
"checked_file": "Hacl.Bignum25519.fsti.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl... | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Bignum25519.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.gsub"
] | [] | module Hacl.Bignum25519
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
module BSeq = Lib.ByteSequence
module S51 = Hacl.Spec.Curve25519.Field51.Definition
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
... | false | false | Hacl.Bignum25519.fsti | {
"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 gett (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 15ul 5ul /\ h0 == h1) | [] | Hacl.Bignum25519.gett | {
"file_name": "code/ed25519/Hacl.Bignum25519.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Hacl.Bignum25519.felem | {
"end_col": 18,
"end_line": 47,
"start_col": 4,
"start_line": 47
} |
FStar.HyperStack.ST.Stack | val getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": "S51"
},
{
... | false | let getx (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1)
= sub p 0ul 5ul | val getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1)
let getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = | true | null | false | sub p 0ul 5ul | {
"checked_file": "Hacl.Bignum25519.fsti.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl... | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Bignum25519.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.gsub"
] | [] | module Hacl.Bignum25519
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Buffer
module BSeq = Lib.ByteSequence
module S51 = Hacl.Spec.Curve25519.Field51.Definition
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
... | false | false | Hacl.Bignum25519.fsti | {
"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 getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) | [] | Hacl.Bignum25519.getx | {
"file_name": "code/ed25519/Hacl.Bignum25519.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Hacl.Bignum25519.felem | {
"end_col": 17,
"end_line": 29,
"start_col": 4,
"start_line": 29
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | false | let nb = 4 | let nb = | false | null | false | 4 | {
"checked_file": "Vale.AES.AES_common_s.fst.checked",
"dependencies": [
"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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst... | [
"total"
] | [] | [] | module Vale.AES.AES_common_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Va... | false | true | Vale.AES.AES_common_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 nb : Prims.int | [] | Vale.AES.AES_common_s.nb | {
"file_name": "vale/specs/crypto/Vale.AES.AES_common_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 10,
"end_line": 36,
"start_col": 9,
"start_line": 36
} | |
Prims.Tot | val is_aes_key (alg: algorithm) (s: seq nat8) : prop0 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | false | let is_aes_key (alg:algorithm) (s:seq nat8) : prop0 = length s == 4 * nk alg | val is_aes_key (alg: algorithm) (s: seq nat8) : prop0
let is_aes_key (alg: algorithm) (s: seq nat8) : prop0 = | false | null | false | length s == 4 * nk alg | {
"checked_file": "Vale.AES.AES_common_s.fst.checked",
"dependencies": [
"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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst... | [
"total"
] | [
"Vale.AES.AES_common_s.algorithm",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"Vale.AES.AES_common_s.nk",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.AES.AES_common_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Va... | false | true | Vale.AES.AES_common_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 is_aes_key (alg: algorithm) (s: seq nat8) : prop0 | [] | Vale.AES.AES_common_s.is_aes_key | {
"file_name": "vale/specs/crypto/Vale.AES.AES_common_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | alg: Vale.AES.AES_common_s.algorithm -> s: FStar.Seq.Base.seq Vale.Def.Types_s.nat8
-> Vale.Def.Prop_s.prop0 | {
"end_col": 76,
"end_line": 52,
"start_col": 54,
"start_line": 52
} |
Prims.Tot | val aes_rcon (i: int) : nat32 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | false | let aes_rcon (i:int) : nat32 =
if i = 0 then 0x01 else
if i = 1 then 0x02 else
if i = 2 then 0x04 else
if i = 3 then 0x08 else
if i = 4 then 0x10 else
if i = 5 then 0x20 else
if i = 6 then 0x40 else
if i = 7 then 0x80 else
if i = 8 then 0x1b else
0x36 | val aes_rcon (i: int) : nat32
let aes_rcon (i: int) : nat32 = | false | null | false | if i = 0
then 0x01
else
if i = 1
then 0x02
else
if i = 2
then 0x04
else
if i = 3
then 0x08
else
if i = 4
then 0x10
else
if i = 5
then 0x20
else if i = 6 then 0x40 else if i = 7 then 0x80 else if i = 8 then 0x1b else 0x36 | {
"checked_file": "Vale.AES.AES_common_s.fst.checked",
"dependencies": [
"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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst... | [
"total"
] | [
"Prims.int",
"Prims.op_Equality",
"Prims.bool",
"Vale.Def.Types_s.nat32"
] | [] | module Vale.AES.AES_common_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Va... | false | true | Vale.AES.AES_common_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 aes_rcon (i: int) : nat32 | [] | Vale.AES.AES_common_s.aes_rcon | {
"file_name": "vale/specs/crypto/Vale.AES.AES_common_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: Prims.int -> Vale.Def.Types_s.nat32 | {
"end_col": 6,
"end_line": 33,
"start_col": 2,
"start_line": 24
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | false | let nr(alg:algorithm) =
match alg with
| AES_128 -> 10
| AES_192 -> 12
| AES_256 -> 14 | let nr (alg: algorithm) = | false | null | false | match alg with
| AES_128 -> 10
| AES_192 -> 12
| AES_256 -> 14 | {
"checked_file": "Vale.AES.AES_common_s.fst.checked",
"dependencies": [
"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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst... | [
"total"
] | [
"Vale.AES.AES_common_s.algorithm",
"Prims.int"
] | [] | module Vale.AES.AES_common_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Va... | false | true | Vale.AES.AES_common_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 nr : alg: Vale.AES.AES_common_s.algorithm -> Prims.int | [] | Vale.AES.AES_common_s.nr | {
"file_name": "vale/specs/crypto/Vale.AES.AES_common_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | alg: Vale.AES.AES_common_s.algorithm -> Prims.int | {
"end_col": 17,
"end_line": 50,
"start_col": 2,
"start_line": 47
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | false | let nk(alg:algorithm) =
match alg with
| AES_128 -> 4
| AES_192 -> 6
| AES_256 -> 8 | let nk (alg: algorithm) = | false | null | false | match alg with
| AES_128 -> 4
| AES_192 -> 6
| AES_256 -> 8 | {
"checked_file": "Vale.AES.AES_common_s.fst.checked",
"dependencies": [
"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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst... | [
"total"
] | [
"Vale.AES.AES_common_s.algorithm",
"Prims.int"
] | [] | module Vale.AES.AES_common_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Va... | false | true | Vale.AES.AES_common_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 nk : alg: Vale.AES.AES_common_s.algorithm -> Prims.int | [] | Vale.AES.AES_common_s.nk | {
"file_name": "vale/specs/crypto/Vale.AES.AES_common_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | alg: Vale.AES.AES_common_s.algorithm -> Prims.int | {
"end_col": 16,
"end_line": 43,
"start_col": 2,
"start_line": 40
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let extract_st (a:fixed_len_alg) =
prk : B.buffer uint8 ->
salt : B.buffer uint8 ->
saltlen : pub_uint32 ->
ikm : B.buffer uint8 ->
ikmlen : pub_uint32 ->
Stack unit
(requires fun h0 ->
B.live h0 prk /\ B.live h0 salt /\ B.live h0 ikm /\
B.disjoint salt prk /\ B.disjoint ikm prk /\
... | let extract_st (a: fixed_len_alg) = | false | null | false |
prk: B.buffer uint8 ->
salt: B.buffer uint8 ->
saltlen: pub_uint32 ->
ikm: B.buffer uint8 ->
ikmlen: pub_uint32
-> Stack unit
(requires
fun h0 ->
B.live h0 prk /\ B.live h0 salt /\ B.live h0 ikm /\ B.disjoint salt prk /\
B.disjoint ikm prk /\ B.length prk == hash... | {
"checked_file": "EverCrypt.HKDF.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FS... | [
"total"
] | [
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"Lib.IntTypes.pub_uint32",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.disjoint",
"Prims.eq2",
... | [] | (** Agile HKDF *)
module EverCrypt.HKDF
module B = LowStar.Buffer
open Spec.Agile.HKDF
open Spec.Hash.Definitions
open FStar.HyperStack.ST
open Lib.IntTypes
#set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 20"
/// Auxiliary lemmas
let key_and_data_fits (a:hash_alg) :
Lemma ((block_length a + pow2 32) `less_t... | false | true | EverCrypt.HKDF.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val extract_st : a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | [] | EverCrypt.HKDF.extract_st | {
"file_name": "providers/evercrypt/EverCrypt.HKDF.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | {
"end_col": 70,
"end_line": 52,
"start_col": 2,
"start_line": 35
} | |
FStar.Pervasives.Lemma | val key_and_data_fits (a: hash_alg)
: Lemma ((block_length a + pow2 32) `less_than_max_input_length` a) | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let key_and_data_fits (a:hash_alg) :
Lemma ((block_length a + pow2 32) `less_than_max_input_length` a)
=
let open FStar.Mul in
assert_norm (8 * 16 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125) | val key_and_data_fits (a: hash_alg)
: Lemma ((block_length a + pow2 32) `less_than_max_input_length` a)
let key_and_data_fits (a: hash_alg)
: Lemma ((block_length a + pow2 32) `less_than_max_input_length` a) = | false | null | true | let open FStar.Mul in
assert_norm (8 * 16 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125) | {
"checked_file": "EverCrypt.HKDF.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FS... | [
"lemma"
] | [
"Spec.Hash.Definitions.hash_alg",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.unit",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.l_True",
"Prims.squash",
"Spec.Hash.Definitions.less_than_max_input_length",
"Spec.Hash.Definitions.block_length",
... | [] | (** Agile HKDF *)
module EverCrypt.HKDF
module B = LowStar.Buffer
open Spec.Agile.HKDF
open Spec.Hash.Definitions
open FStar.HyperStack.ST
open Lib.IntTypes
#set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 20"
/// Auxiliary lemmas
let key_and_data_fits (a:hash_alg) :
Lemma ((block_length a + pow2 32) `less_t... | false | false | EverCrypt.HKDF.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val key_and_data_fits (a: hash_alg)
: Lemma ((block_length a + pow2 32) `less_than_max_input_length` a) | [] | EverCrypt.HKDF.key_and_data_fits | {
"file_name": "providers/evercrypt/EverCrypt.HKDF.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Hash.Definitions.hash_alg
-> FStar.Pervasives.Lemma
(ensures
Spec.Hash.Definitions.less_than_max_input_length (Spec.Hash.Definitions.block_length a +
Prims.pow2 32)
a) | {
"end_col": 34,
"end_line": 21,
"start_col": 2,
"start_line": 19
} |
FStar.Pervasives.Lemma | val hash_block_length_fits (a: hash_alg)
: Lemma
(if is_keccak a
then True
else hash_length a + pow2 32 + block_length a < Some?.v (max_input_length a)) | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let hash_block_length_fits (a:hash_alg) :
Lemma (if is_keccak a then True else hash_length a + pow2 32 + block_length a < Some?.v(max_input_length a))
=
let open FStar.Mul in
assert_norm (8 * 16 + 8 * 8 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125) | val hash_block_length_fits (a: hash_alg)
: Lemma
(if is_keccak a
then True
else hash_length a + pow2 32 + block_length a < Some?.v (max_input_length a))
let hash_block_length_fits (a: hash_alg)
: Lemma
(if is_keccak a
then True
else hash_length a + pow2 32 + block_length a < Some... | false | null | true | let open FStar.Mul in
assert_norm (8 * 16 + 8 * 8 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125) | {
"checked_file": "EverCrypt.HKDF.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FS... | [
"lemma"
] | [
"Spec.Hash.Definitions.hash_alg",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.unit",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.l_True",
"Prims.squash",
"Spec.Hash.Definitions.is_keccak",
"Prims.bool",
"Spec.Hash.Definitions.hash_length",
"S... | [] | (** Agile HKDF *)
module EverCrypt.HKDF
module B = LowStar.Buffer
open Spec.Agile.HKDF
open Spec.Hash.Definitions
open FStar.HyperStack.ST
open Lib.IntTypes
#set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 20"
/// Auxiliary lemmas
let key_and_data_fits (a:hash_alg) :
Lemma ((block_length a + pow2 32) `less_t... | false | false | EverCrypt.HKDF.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val hash_block_length_fits (a: hash_alg)
: Lemma
(if is_keccak a
then True
else hash_length a + pow2 32 + block_length a < Some?.v (max_input_length a)) | [] | EverCrypt.HKDF.hash_block_length_fits | {
"file_name": "providers/evercrypt/EverCrypt.HKDF.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Hash.Definitions.hash_alg
-> FStar.Pervasives.Lemma
(ensures
((match Spec.Hash.Definitions.is_keccak a with
| true -> Prims.l_True
| _ ->
Spec.Hash.Definitions.hash_length a + Prims.pow2 32 +
Spec.Hash.Definitions.block_length a <
Some?.v (Spec... | {
"end_col": 34,
"end_line": 28,
"start_col": 2,
"start_line": 26
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let expand_st (a:fixed_len_alg) =
okm : B.buffer uint8 ->
prk : B.buffer uint8 ->
prklen : pub_uint32 ->
info : B.buffer uint8 ->
infolen : pub_uint32 ->
len : pub_uint32 ->
Stack unit
(requires fun h0 ->
B.live h0 okm /\ B.live h0 prk /\ B.live h0 info /\
B.disjoint okm prk /\
... | let expand_st (a: fixed_len_alg) = | false | null | false |
okm: B.buffer uint8 ->
prk: B.buffer uint8 ->
prklen: pub_uint32 ->
info: B.buffer uint8 ->
infolen: pub_uint32 ->
len: pub_uint32
-> Stack unit
(requires
fun h0 ->
B.live h0 okm /\ B.live h0 prk /\ B.live h0 info /\ B.disjoint okm prk /\
v prklen == B.length... | {
"checked_file": "EverCrypt.HKDF.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FS... | [
"total"
] | [
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"Lib.IntTypes.pub_uint32",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.disjoint",
"Prims.eq2",
... | [] | (** Agile HKDF *)
module EverCrypt.HKDF
module B = LowStar.Buffer
open Spec.Agile.HKDF
open Spec.Hash.Definitions
open FStar.HyperStack.ST
open Lib.IntTypes
#set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 20"
/// Auxiliary lemmas
let key_and_data_fits (a:hash_alg) :
Lemma ((block_length a + pow2 32) `less_t... | false | true | EverCrypt.HKDF.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val expand_st : a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | [] | EverCrypt.HKDF.expand_st | {
"file_name": "providers/evercrypt/EverCrypt.HKDF.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | {
"end_col": 77,
"end_line": 76,
"start_col": 2,
"start_line": 56
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"shor... | false | let fixed_i f (i:nat) = f | let fixed_i f (i: nat) = | false | null | false | f | {
"checked_file": "Lib.LoopCombinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Lib.LoopCombinators.fsti"
} | [
"total"
] | [
"Prims.nat"
] | [] | module Lib.LoopCombinators
(**
* fold_left-like loop combinator:
* [ repeat_left lo hi a f acc == f (hi - 1) .. ... (f (lo + 1) (f lo acc)) ]
*
* e.g. [ repeat_left 0 3 (fun _ -> list int) Cons [] == [2;1;0] ]
*
* It satisfies
* [ repeat_left lo hi (fun _ -> a) f acc == fold_left (flip f) acc [lo..hi-1] ]
*
* A simple... | false | false | Lib.LoopCombinators.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 fixed_i : f: _ -> i: Prims.nat -> _ | [] | Lib.LoopCombinators.fixed_i | {
"file_name": "lib/Lib.LoopCombinators.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: _ -> i: Prims.nat -> _ | {
"end_col": 25,
"end_line": 156,
"start_col": 24,
"start_line": 156
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"shor... | false | let fixed_a (a:Type) (i:nat) = a | let fixed_a (a: Type) (i: nat) = | false | null | false | a | {
"checked_file": "Lib.LoopCombinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Lib.LoopCombinators.fsti"
} | [
"total"
] | [
"Prims.nat"
] | [] | module Lib.LoopCombinators
(**
* fold_left-like loop combinator:
* [ repeat_left lo hi a f acc == f (hi - 1) .. ... (f (lo + 1) (f lo acc)) ]
*
* e.g. [ repeat_left 0 3 (fun _ -> list int) Cons [] == [2;1;0] ]
*
* It satisfies
* [ repeat_left lo hi (fun _ -> a) f acc == fold_left (flip f) acc [lo..hi-1] ]
*
* A simple... | false | true | Lib.LoopCombinators.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 fixed_a : a: Type -> i: Prims.nat -> Type | [] | Lib.LoopCombinators.fixed_a | {
"file_name": "lib/Lib.LoopCombinators.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Type -> i: Prims.nat -> Type | {
"end_col": 32,
"end_line": 154,
"start_col": 31,
"start_line": 154
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let uint64_t = UInt64.t | let uint64_t = | false | null | false | UInt64.t | {
"checked_file": "EverCrypt.Helpers.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperSta... | [
"total"
] | [
"FStar.UInt64.t"
] | [] | module EverCrypt.Helpers
module B = LowStar.Buffer
open FStar.HyperStack.ST
/// Small helpers
inline_for_extraction noextract
let (!$) = C.String.((!$))
/// For the time being, we do not write any specifications and just try to reach
/// agreement on calling conventions. A series of convenient type abbreviations
//... | false | true | EverCrypt.Helpers.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 uint64_t : Prims.eqtype | [] | EverCrypt.Helpers.uint64_t | {
"file_name": "providers/evercrypt/EverCrypt.Helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.eqtype | {
"end_col": 23,
"end_line": 24,
"start_col": 15,
"start_line": 24
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.