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
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 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
sequencelengths 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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 +. rb) *. rc %. g);
== {lemma_mul_distribute_left ra rb rc}
rev ((ra *. rc +. rb *. rc) %. g);
== {lemma_mod_distribute (ra *. rc) (rb *. rc) g}
rev (ra *. rc %. g +. rb *. rc %. g);
== {lemma_add_reverse (ra *. rc %. g) (rb *. rc %. g) 127}
rev (ra *. rc %. g) +. rev (rb *. rc %. g);
== {}
(a *~ c) +. (b *~ c);
} | 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 rb rc }
rev ((ra *. rc +. rb *. rc) %. g);
( == ) { lemma_mod_distribute (ra *. rc) (rb *. rc) g }
rev (ra *. rc %. g +. rb *. rc %. g);
( == ) { lemma_add_reverse (ra *. rc %. g) (rb *. rc %. g) 127 }
rev (ra *. rc %. g) +. rev (rb *. rc %. g);
( == ) { () }
(a *~ c) +. (b *~ c);
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Vale.Math.Poly2.Lemmas.lemma_add_reverse",
"Vale.Math.Poly2.Lemmas.lemma_mul_distribute_left",
"Vale.Math.Poly2.Lemmas.lemma_mod_distribute",
"Vale.AES.GF128.lemma_gf128_degree",
"Vale.AES.GF128_s.gf128_modulus",
"Vale.Math.Poly2_s.reverse"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
}
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 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)
}
to_quad32 (reverse r3 127);
}
}
shift (of_quad32 (to_quad32 (reverse r3 127))) (-64);
== {lemma_of_to_quad32 (reverse r3 127)}
shift (reverse r3 127) (-64);
== {
lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (-64)) (reverse r3 63)
}
reverse r3 63;
}
let lemma_gf128_high_bit () =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0x80000000 in
let a = monomial 127 in
let a3 = monomial 31 in
calc (==) {
of_quad32 (Mkfour n0 n1 n2 n3);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
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);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a0 n0;
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
let lemma_gf128_mul_rev_commute a b =
lemma_mul_all ()
let lemma_gf128_mul_rev_associate 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 (ra *. (rb *. rc %. g) %. g);
== {lemma_mod_mul_mod_right ra (rb *. rc) g}
rev (ra *. (rb *. rc) %. g);
== {lemma_mul_associate ra rb rc}
rev ((ra *. rb) *. rc %. g);
== {lemma_mod_mul_mod (ra *. rb) g rc}
rev ((ra *. rb %. g) *. rc %. g);
== {}
(a *~ b) *~ c;
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 - 1) 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 *. h) in
degree (r rdhL) <= 2 * degree h /\
degree (r rdhLh) <= 2 * degree h /\
r ((a *. b) %. g) == rdhLh +. rdh /. m +. rab /. 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": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
() | 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 - 1) 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 *. h) in
degree (r rdhL) <= 2 * degree h /\
degree (r rdhLh) <= 2 * degree h /\
r ((a *. b) %. g) == rdhLh +. rdh /. m +. rab /. m
))
let lemma_gf128_reduce_rev a b h 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 *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
() | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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_split_define",
"Vale.Math.Poly2.Lemmas.lemma_index_all",
"Vale.Math.Poly2.Lemmas.lemma_reverse_define_all",
"Vale.Math.Poly2.Lemmas.lemma_add_define_all",
"Vale.Math.Poly2_s.reverse",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Vale.AES.GF128.lemma_gf128_reduce",
"Vale.Math.Poly2_s.monomial"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
() | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 - 1) 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 *. h) in
degree (r rdhL) <= 2 * degree h /\
degree (r rdhLh) <= 2 * degree h /\
r ((a *. b) %. g) == rdhLh +. rdh /. m +. rab /. m
)) | [] | 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.Poly2_s.degree a < n /\ Vale.Math.Poly2_s.degree b < n)
(ensures
(let m = Vale.Math.Poly2_s.monomial n in
let g = m +. h in
let r x = Vale.Math.Poly2_s.reverse x (n - 1) in
let rr x = Vale.Math.Poly2_s.reverse x (2 * n - 1) 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 *. h) in
Vale.Math.Poly2_s.degree (r rdhL) <= 2 * Vale.Math.Poly2_s.degree h /\
Vale.Math.Poly2_s.degree (r rdhLh) <= 2 * Vale.Math.Poly2_s.degree h /\
r (a *. b %. g) == rdhLh +. rdh /. m +. rab /. m)) | {
"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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a0 n0;
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
} | 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 }
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
( == ) { (lemma_bitwise_all ();
lemma_to_nat 32 a0 n0;
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a) }
of_quad32 (to_quad32 a);
( == ) { lemma_of_to_quad32 a }
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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.Poly2.Bits.poly128_of_nat32s",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.Bits.lemma_quad32_of_nat32s",
"Prims.squash",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Bits.lemma_to_nat",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Vale.Math.Poly2.Bits.lemma_of_to_quad32",
"Vale.Math.Poly2_s.reverse",
"Vale.AES.GF128.gf128_low_shift",
"Vale.Math.Poly2_s.one",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.monomial",
"Vale.AES.GF128_s.gf128_modulus_low_terms",
"Prims.op_Minus",
"Vale.Def.Words_s.nat32"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
}
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 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)
}
to_quad32 (reverse r3 127);
}
}
shift (of_quad32 (to_quad32 (reverse r3 127))) (-64);
== {lemma_of_to_quad32 (reverse r3 127)}
shift (reverse r3 127) (-64);
== {
lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (-64)) (reverse r3 63)
}
reverse r3 63;
}
let lemma_gf128_high_bit () =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0x80000000 in
let a = monomial 127 in
let a3 = monomial 31 in
calc (==) {
of_quad32 (Mkfour n0 n1 n2 n3);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
} | 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 h n = | 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);
( == ) { lemma_mul_all () }
reverse a n1 *. (monomial 1 *. reverse h n1);
( == ) { lemma_shift_is_mul_left (reverse h n1) 1 }
reverse a n1 *. shift (reverse h n1) 1;
( == ) { lemma_odd_reverse_shift_right h n }
reverse a n1 *. (m +. reverse (shift h (- 1)) n1);
( == ) { lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (- 1)) n1) }
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (- 1)) n1;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.Calc.calc_step",
"Vale.Math.Poly2_s.monomial",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.Lemmas.lemma_mul_reverse_shift_1",
"Prims.squash",
"Vale.Math.Poly2.Lemmas.lemma_shift_is_mul_left",
"Vale.Math.Poly2.Lemmas.lemma_mul_all",
"Vale.AES.GF128.lemma_odd_reverse_shift_right",
"Vale.Math.Poly2.Lemmas.lemma_mul_distribute_right",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Addition"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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
)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (a *. h) (n + n - 1) ==
Vale.Math.Poly2_s.reverse a n1 *. m +.
Vale.Math.Poly2_s.reverse a n1 *.
Vale.Math.Poly2_s.reverse (Vale.Math.Poly2_s.shift h (- 1)) n1)) | {
"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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 ();
lemma_equal (shift (rev (mask h1 n +. offset)) 1) (rev h +. g)
}
(rev h +. g) %. g;
== {lemma_mod_distribute (rev h) g g; lemma_mod_cancel g; lemma_add_all ()}
rev h %. g;
}
else
calc (==) {
shift (rev (mask h1 n +. zero)) 1 %. g;
== {
lemma_bitwise_all ();
lemma_equal (shift (rev (mask h1 n +. zero)) 1) (rev h)
}
rev h %. g;
} | 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 +. offset)) 1) (rev h +. g)) }
(rev h +. g) %. g;
( == ) { (lemma_mod_distribute (rev h) g g;
lemma_mod_cancel g;
lemma_add_all ()) }
rev h %. g;
}
else
calc ( == ) {
shift (rev (mask h1 n +. zero)) 1 %. g;
( == ) { (lemma_bitwise_all ();
lemma_equal (shift (rev (mask h1 n +. zero)) 1) (rev h)) }
rev h %. g;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Prims.squash",
"Vale.Math.Poly2.Lemmas.lemma_add_all",
"Vale.Math.Poly2.Lemmas.lemma_mod_cancel",
"Vale.Math.Poly2.Lemmas.lemma_mod_distribute",
"Prims.bool",
"Vale.Math.Poly2_s.zero",
"Vale.Math.Poly2_s.reverse",
"Prims.op_Minus",
"Prims.op_Subtraction",
"Vale.Math.Poly2.Lemmas.lemma_monomial_add_degree",
"Vale.Math.Poly2_s.monomial"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
}
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 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)
}
to_quad32 (reverse r3 127);
}
}
shift (of_quad32 (to_quad32 (reverse r3 127))) (-64);
== {lemma_of_to_quad32 (reverse r3 127)}
shift (reverse r3 127) (-64);
== {
lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (-64)) (reverse r3 63)
}
reverse r3 63;
}
let lemma_gf128_high_bit () =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0x80000000 in
let a = monomial 127 in
let a3 = monomial 31 in
calc (==) {
of_quad32 (Mkfour n0 n1 n2 n3);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
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);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a0 n0;
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
let lemma_gf128_mul_rev_commute a b =
lemma_mul_all ()
let lemma_gf128_mul_rev_associate 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 (ra *. (rb *. rc %. g) %. g);
== {lemma_mod_mul_mod_right ra (rb *. rc) g}
rev (ra *. (rb *. rc) %. g);
== {lemma_mul_associate ra rb rc}
rev ((ra *. rb) *. rc %. g);
== {lemma_mod_mul_mod (ra *. rb) g rc}
rev ((ra *. rb %. g) *. rc %. g);
== {}
(a *~ b) *~ c;
}
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 +. rb) *. rc %. g);
== {lemma_mul_distribute_left ra rb rc}
rev ((ra *. rc +. rb *. rc) %. g);
== {lemma_mod_distribute (ra *. rc) (rb *. rc) g}
rev (ra *. rc %. g +. rb *. rc %. g);
== {lemma_add_reverse (ra *. rc %. g) (rb *. rc %. g) 127}
rev (ra *. rc %. g) +. rev (rb *. rc %. g);
== {}
(a *~ c) +. (b *~ c);
}
let lemma_gf128_mul_rev_distribute_right a b c =
calc (==) {
a *~ (b +. c);
== {lemma_gf128_mul_rev_commute a (b +. c)}
(b +. c) *~ a;
== {lemma_gf128_mul_rev_distribute_left b c a}
b *~ a +. c *~ a;
== {lemma_gf128_mul_rev_commute a b; lemma_gf128_mul_rev_commute a c}
a *~ b +. a *~ c;
}
let lemma_add_mod_rev n a1 a2 b =
let rev x = reverse x (n - 1) in
let rev' x = reverse x (n + n - 1) in
calc (==) {
// mod_rev n (a1 +. a2) b;
rev (rev' (a1 +. a2) %. b);
== {lemma_add_reverse a1 a2 (n + n - 1)}
rev ((rev' a1 +. rev' a2) %. b);
== {lemma_mod_distribute (rev' a1) (rev' a2) b}
rev (rev' a1 %. b +. rev' a2 %. b);
== {lemma_add_reverse (rev' a1 %. b) (rev' a2 %. b) (n - 1)}
rev (rev' a1 %. b) +. rev (rev' a2 %. b);
// mod_rev n a1 b +. mod_rev n a2 b
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.reverse (Vale.AES.GF128.shift_key_1 n f h)
(n - 1))
1 %.
g ==
Vale.Math.Poly2_s.reverse h (n - 1) %. g)) | {
"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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)
}
to_quad32 (reverse r3 127);
}
}
shift (of_quad32 (to_quad32 (reverse r3 127))) (-64);
== {lemma_of_to_quad32 (reverse r3 127)}
shift (reverse r3 127) (-64);
== {
lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (-64)) (reverse r3 63)
}
reverse r3 63;
} | 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 n3);
( == ) { (lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)) }
to_quad32 (reverse r3 127);
} }
shift (of_quad32 (to_quad32 (reverse r3 127))) (- 64);
( == ) { lemma_of_to_quad32 (reverse r3 127) }
shift (reverse r3 127) (- 64);
( == ) { (lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (- 64)) (reverse r3 63)) }
reverse r3 63;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.Nil",
"FStar.Calc.calc_step",
"Vale.Math.Poly2.Bits_s.to_quad32",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.nat32",
"Vale.Math.Poly2.Bits.poly128_of_nat32s",
"Vale.Math.Poly2.Bits.lemma_quad32_of_nat32s",
"Prims.squash",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Bits.lemma_to_nat",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Vale.Math.Poly2.Bits.lemma_of_to_quad32",
"Vale.AES.GF128.gf128_low_shift"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 64);
== {lemma_mul_distribute_left aL (shift aH 64) (bL +. shift bH 64)}
aL *. (bL +. shift bH 64) +. shift aH 64 *. (bL +. shift bH 64);
== {lemma_mul_distribute_right aL bL (shift bH 64)}
aL *. bL +. aL *. shift bH 64 +. shift aH 64 *. (bL +. shift bH 64);
== {lemma_mul_distribute_right (shift aH 64) bL (shift bH 64)}
aL *. bL +. aL *. shift bH 64 +. (shift aH 64 *. bL +. shift aH 64 *. shift bH 64);
== {lemma_add_all ()}
aL *. bL +. (aL *. shift bH 64 +. shift aH 64 *. bL) +. shift aH 64 *. shift bH 64;
== {lemma_shift_is_mul aH 64; lemma_shift_is_mul bH 64}
aL *. bL +. (aL *. (bH *. monomial 64) +. aH *. monomial 64 *. bL) +. aH *. monomial 64 *. (bH *. monomial 64);
== {lemma_mul_all ()}
aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. (monomial 64 *. monomial 64);
== {lemma_mul_monomials 64 64}
aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. monomial 128;
== {lemma_mul_distribute_left (aL *. bH) (aH *. bL) (monomial 64)}
aL *. bL +. (aL *. bH +. aH *. bL) *. monomial 64 +. aH *. bH *. monomial 128;
== {lemma_shift_is_mul (aL *. bH +. aH *. bL) 64; lemma_shift_is_mul (aH *. bH) 128}
aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128;
} | 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 aL (shift aH 64) (bL +. shift bH 64) }
aL *. (bL +. shift bH 64) +. shift aH 64 *. (bL +. shift bH 64);
( == ) { lemma_mul_distribute_right aL bL (shift bH 64) }
aL *. bL +. aL *. shift bH 64 +. shift aH 64 *. (bL +. shift bH 64);
( == ) { lemma_mul_distribute_right (shift aH 64) bL (shift bH 64) }
aL *. bL +. aL *. shift bH 64 +. (shift aH 64 *. bL +. shift aH 64 *. shift bH 64);
( == ) { lemma_add_all () }
aL *. bL +. (aL *. shift bH 64 +. shift aH 64 *. bL) +. shift aH 64 *. shift bH 64;
( == ) { (lemma_shift_is_mul aH 64;
lemma_shift_is_mul bH 64) }
aL *. bL +. (aL *. (bH *. monomial 64) +. aH *. monomial 64 *. bL) +.
aH *. monomial 64 *. (bH *. monomial 64);
( == ) { lemma_mul_all () }
aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +.
aH *. bH *. (monomial 64 *. monomial 64);
( == ) { lemma_mul_monomials 64 64 }
aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. monomial 128;
( == ) { lemma_mul_distribute_left (aL *. bH) (aH *. bL) (monomial 64) }
aL *. bL +. (aL *. bH +. aH *. bL) *. monomial 64 +. aH *. bH *. monomial 128;
( == ) { (lemma_shift_is_mul (aL *. bH +. aH *. bL) 64;
lemma_shift_is_mul (aH *. bH) 128) }
aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Prims.squash",
"Vale.Math.Poly2.Lemmas.lemma_mul_distribute_left",
"Vale.Math.Poly2.Lemmas.lemma_mul_distribute_right",
"Vale.Math.Poly2.Lemmas.lemma_add_all",
"Vale.Math.Poly2.lemma_shift_is_mul",
"Vale.Math.Poly2.Lemmas.lemma_mul_all",
"Vale.Math.Poly2.Lemmas.lemma_mul_monomials",
"Prims.op_Minus",
"Vale.Math.Poly2.mask"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
}
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 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)
}
to_quad32 (reverse r3 127);
}
}
shift (of_quad32 (to_quad32 (reverse r3 127))) (-64);
== {lemma_of_to_quad32 (reverse r3 127)}
shift (reverse r3 127) (-64);
== {
lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (-64)) (reverse r3 63)
}
reverse r3 63;
}
let lemma_gf128_high_bit () =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0x80000000 in
let a = monomial 127 in
let a3 = monomial 31 in
calc (==) {
of_quad32 (Mkfour n0 n1 n2 n3);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
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);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a0 n0;
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
let lemma_gf128_mul_rev_commute a b =
lemma_mul_all ()
let lemma_gf128_mul_rev_associate 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 (ra *. (rb *. rc %. g) %. g);
== {lemma_mod_mul_mod_right ra (rb *. rc) g}
rev (ra *. (rb *. rc) %. g);
== {lemma_mul_associate ra rb rc}
rev ((ra *. rb) *. rc %. g);
== {lemma_mod_mul_mod (ra *. rb) g rc}
rev ((ra *. rb %. g) *. rc %. g);
== {}
(a *~ b) *~ c;
}
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 +. rb) *. rc %. g);
== {lemma_mul_distribute_left ra rb rc}
rev ((ra *. rc +. rb *. rc) %. g);
== {lemma_mod_distribute (ra *. rc) (rb *. rc) g}
rev (ra *. rc %. g +. rb *. rc %. g);
== {lemma_add_reverse (ra *. rc %. g) (rb *. rc %. g) 127}
rev (ra *. rc %. g) +. rev (rb *. rc %. g);
== {}
(a *~ c) +. (b *~ c);
}
let lemma_gf128_mul_rev_distribute_right a b c =
calc (==) {
a *~ (b +. c);
== {lemma_gf128_mul_rev_commute a (b +. c)}
(b +. c) *~ a;
== {lemma_gf128_mul_rev_distribute_left b c a}
b *~ a +. c *~ a;
== {lemma_gf128_mul_rev_commute a b; lemma_gf128_mul_rev_commute a c}
a *~ b +. a *~ c;
}
let lemma_add_mod_rev n a1 a2 b =
let rev x = reverse x (n - 1) in
let rev' x = reverse x (n + n - 1) in
calc (==) {
// mod_rev n (a1 +. a2) b;
rev (rev' (a1 +. a2) %. b);
== {lemma_add_reverse a1 a2 (n + n - 1)}
rev ((rev' a1 +. rev' a2) %. b);
== {lemma_mod_distribute (rev' a1) (rev' a2) b}
rev (rev' a1 %. b +. rev' a2 %. b);
== {lemma_add_reverse (rev' a1 %. b) (rev' a2 %. b) (n - 1)}
rev (rev' a1 %. b) +. rev (rev' a2 %. b);
// mod_rev n a1 b +. mod_rev n a2 b
}
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 ();
lemma_equal (shift (rev (mask h1 n +. offset)) 1) (rev h +. g)
}
(rev h +. g) %. g;
== {lemma_mod_distribute (rev h) g g; lemma_mod_cancel g; lemma_add_all ()}
rev h %. g;
}
else
calc (==) {
shift (rev (mask h1 n +. zero)) 1 %. g;
== {
lemma_bitwise_all ();
lemma_equal (shift (rev (mask h1 n +. zero)) 1) (rev h)
}
rev h %. g;
}
let lemma_test_high_bit a =
calc (==) {
of_nat ((to_quad32 (monomial 127)).hi3);
== {lemma_quad32_extract_nat32s (monomial 127)}
shift (monomial 127) (-96);
};
calc (==) {
of_nat (to_quad32 (poly_and a (monomial 127))).hi3;
== {lemma_quad32_extract_nat32s (poly_and a (monomial 127))}
shift (poly_and a (monomial 127)) (-96);
};
if (shift (monomial 127) (-96) = shift (poly_and a (monomial 127)) (-96)) then
(
of_nat32_eq (to_quad32 (poly_and a (monomial 127))).hi3 ((to_quad32 (monomial 127)).hi3);
lemma_bitwise_all ();
assert ((shift (monomial 127) (-96)).[31]);
assert ((shift (poly_and a (monomial 127)) (-96)).[31]);
assert (a.[127]);
()
);
if a.[127] then
(
lemma_bitwise_all ();
lemma_equal (shift (monomial 127) (-96)) (shift (poly_and a (monomial 127)) (-96));
()
) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.shift a (- 64) in
let bH = Vale.Math.Poly2_s.shift b (- 64) in
a *. b ==
aL *. bL +. Vale.Math.Poly2_s.shift (aL *. bH +. aH *. bL) 64 +.
Vale.Math.Poly2_s.shift (aH *. bH) 128)) | {
"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 +. aL *. bH +. aH *. bL) 64 +. shift (z2 +. 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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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) 128);
== {lemma_shift_is_mul (aL *. bH +. aH *. bL) 64; lemma_shift_is_mul (aH *. bH) 128}
z +. (aL *. bL +. (aL *. bH +. aH *. bL) *. monomial 64 +. aH *. bH *. monomial 128);
== {lemma_mul_distribute_left (aL *. bH) (aH *. bL) (monomial 64)}
z +. (aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. monomial 128);
== {lemma_add_all ()}
z0 +. aL *. bL +. (shift z1 64 +. aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. (shift z2 128 +. aH *. bH *. monomial 128);
== {lemma_shift_is_mul z1 64; lemma_shift_is_mul z2 128}
z0 +. aL *. bL +. (z1 *. monomial 64 +. aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. (z2 *. monomial 128 +. aH *. bH *. monomial 128);
== {lemma_mul_distribute_left z1 (aL *. bH) (monomial 64)}
z0 +. aL *. bL +. ((z1 +. aL *. bH) *. monomial 64 +. aH *. bL *. monomial 64) +. (z2 *. monomial 128 +. aH *. bH *. monomial 128);
== {lemma_mul_distribute_left (z1 +. aL *. bH) (aH *. bL) (monomial 64)}
z0 +. aL *. bL +. (z1 +. aL *. bH +. aH *. bL) *. monomial 64 +. (z2 *. monomial 128 +. aH *. bH *. monomial 128);
== {lemma_mul_distribute_left z2 (aH *. bH) (monomial 128)}
z0 +. aL *. bL +. (z1 +. aL *. bH +. aH *. bL) *. monomial 64 +. (z2 +. aH *. bH) *. monomial 128;
== {lemma_shift_is_mul (z1 +. aL *. bH +. aH *. bL) 64; lemma_shift_is_mul (z2 +. aH *. bH) 128}
(z0 +. aL *. bL) +. shift (z1 +. aL *. bH +. aH *. bL) 64 +. shift (z2 +. aH *. bH) 128;
} | 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 +. aL *. bH +. aH *. bL) 64 +. shift (z2 +. aH *. bH) 128
))
let lemma_Mul128_accum z0 z1 z2 a b = | 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 +. aH *. bL) 64;
lemma_shift_is_mul (aH *. bH) 128) }
z +. (aL *. bL +. (aL *. bH +. aH *. bL) *. monomial 64 +. aH *. bH *. monomial 128);
( == ) { lemma_mul_distribute_left (aL *. bH) (aH *. bL) (monomial 64) }
z +.
(aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. monomial 128);
( == ) { lemma_add_all () }
z0 +. aL *. bL +. (shift z1 64 +. aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +.
(shift z2 128 +. aH *. bH *. monomial 128);
( == ) { (lemma_shift_is_mul z1 64;
lemma_shift_is_mul z2 128) }
z0 +. aL *. bL +. (z1 *. monomial 64 +. aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +.
(z2 *. monomial 128 +. aH *. bH *. monomial 128);
( == ) { lemma_mul_distribute_left z1 (aL *. bH) (monomial 64) }
z0 +. aL *. bL +. ((z1 +. aL *. bH) *. monomial 64 +. aH *. bL *. monomial 64) +.
(z2 *. monomial 128 +. aH *. bH *. monomial 128);
( == ) { lemma_mul_distribute_left (z1 +. aL *. bH) (aH *. bL) (monomial 64) }
z0 +. aL *. bL +. (z1 +. aL *. bH +. aH *. bL) *. monomial 64 +.
(z2 *. monomial 128 +. aH *. bH *. monomial 128);
( == ) { lemma_mul_distribute_left z2 (aH *. bH) (monomial 128) }
z0 +. aL *. bL +. (z1 +. aL *. bH +. aH *. bL) *. monomial 64 +. (z2 +. aH *. bH) *. monomial 128;
( == ) { (lemma_shift_is_mul (z1 +. aL *. bH +. aH *. bL) 64;
lemma_shift_is_mul (z2 +. aH *. bH) 128) }
(z0 +. aL *. bL) +. shift (z1 +. aL *. bH +. aH *. bL) 64 +. shift (z2 +. aH *. bH) 128;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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_init",
"FStar.Calc.calc_pack",
"Vale.AES.GF128.lemma_Mul128",
"Prims.squash",
"Vale.Math.Poly2.lemma_shift_is_mul",
"Vale.Math.Poly2.Lemmas.lemma_mul_distribute_left",
"Vale.Math.Poly2.Lemmas.lemma_add_all",
"Prims.op_Minus",
"Vale.Math.Poly2.mask"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
}
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 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse r3 31) n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse r3 127)
}
to_quad32 (reverse r3 127);
}
}
shift (of_quad32 (to_quad32 (reverse r3 127))) (-64);
== {lemma_of_to_quad32 (reverse r3 127)}
shift (reverse r3 127) (-64);
== {
lemma_bitwise_all ();
lemma_equal (shift (reverse r3 127) (-64)) (reverse r3 63)
}
reverse r3 63;
}
let lemma_gf128_high_bit () =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0x80000000 in
let a = monomial 127 in
let a3 = monomial 31 in
calc (==) {
of_quad32 (Mkfour n0 n1 n2 n3);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
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);
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
of_quad32 (to_quad32 (poly128_of_nat32s n0 n1 n2 n3));
== {
lemma_bitwise_all ();
lemma_to_nat 32 a0 n0;
lemma_to_nat 32 a3 n3;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) a
}
of_quad32 (to_quad32 a);
== {lemma_of_to_quad32 a}
a;
}
let lemma_gf128_mul_rev_commute a b =
lemma_mul_all ()
let lemma_gf128_mul_rev_associate 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 (ra *. (rb *. rc %. g) %. g);
== {lemma_mod_mul_mod_right ra (rb *. rc) g}
rev (ra *. (rb *. rc) %. g);
== {lemma_mul_associate ra rb rc}
rev ((ra *. rb) *. rc %. g);
== {lemma_mod_mul_mod (ra *. rb) g rc}
rev ((ra *. rb %. g) *. rc %. g);
== {}
(a *~ b) *~ c;
}
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 +. rb) *. rc %. g);
== {lemma_mul_distribute_left ra rb rc}
rev ((ra *. rc +. rb *. rc) %. g);
== {lemma_mod_distribute (ra *. rc) (rb *. rc) g}
rev (ra *. rc %. g +. rb *. rc %. g);
== {lemma_add_reverse (ra *. rc %. g) (rb *. rc %. g) 127}
rev (ra *. rc %. g) +. rev (rb *. rc %. g);
== {}
(a *~ c) +. (b *~ c);
}
let lemma_gf128_mul_rev_distribute_right a b c =
calc (==) {
a *~ (b +. c);
== {lemma_gf128_mul_rev_commute a (b +. c)}
(b +. c) *~ a;
== {lemma_gf128_mul_rev_distribute_left b c a}
b *~ a +. c *~ a;
== {lemma_gf128_mul_rev_commute a b; lemma_gf128_mul_rev_commute a c}
a *~ b +. a *~ c;
}
let lemma_add_mod_rev n a1 a2 b =
let rev x = reverse x (n - 1) in
let rev' x = reverse x (n + n - 1) in
calc (==) {
// mod_rev n (a1 +. a2) b;
rev (rev' (a1 +. a2) %. b);
== {lemma_add_reverse a1 a2 (n + n - 1)}
rev ((rev' a1 +. rev' a2) %. b);
== {lemma_mod_distribute (rev' a1) (rev' a2) b}
rev (rev' a1 %. b +. rev' a2 %. b);
== {lemma_add_reverse (rev' a1 %. b) (rev' a2 %. b) (n - 1)}
rev (rev' a1 %. b) +. rev (rev' a2 %. b);
// mod_rev n a1 b +. mod_rev n a2 b
}
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 ();
lemma_equal (shift (rev (mask h1 n +. offset)) 1) (rev h +. g)
}
(rev h +. g) %. g;
== {lemma_mod_distribute (rev h) g g; lemma_mod_cancel g; lemma_add_all ()}
rev h %. g;
}
else
calc (==) {
shift (rev (mask h1 n +. zero)) 1 %. g;
== {
lemma_bitwise_all ();
lemma_equal (shift (rev (mask h1 n +. zero)) 1) (rev h)
}
rev h %. g;
}
let lemma_test_high_bit a =
calc (==) {
of_nat ((to_quad32 (monomial 127)).hi3);
== {lemma_quad32_extract_nat32s (monomial 127)}
shift (monomial 127) (-96);
};
calc (==) {
of_nat (to_quad32 (poly_and a (monomial 127))).hi3;
== {lemma_quad32_extract_nat32s (poly_and a (monomial 127))}
shift (poly_and a (monomial 127)) (-96);
};
if (shift (monomial 127) (-96) = shift (poly_and a (monomial 127)) (-96)) then
(
of_nat32_eq (to_quad32 (poly_and a (monomial 127))).hi3 ((to_quad32 (monomial 127)).hi3);
lemma_bitwise_all ();
assert ((shift (monomial 127) (-96)).[31]);
assert ((shift (poly_and a (monomial 127)) (-96)).[31]);
assert (a.[127]);
()
);
if a.[127] then
(
lemma_bitwise_all ();
lemma_equal (shift (monomial 127) (-96)) (shift (poly_and a (monomial 127)) (-96));
()
)
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 64);
== {lemma_mul_distribute_left aL (shift aH 64) (bL +. shift bH 64)}
aL *. (bL +. shift bH 64) +. shift aH 64 *. (bL +. shift bH 64);
== {lemma_mul_distribute_right aL bL (shift bH 64)}
aL *. bL +. aL *. shift bH 64 +. shift aH 64 *. (bL +. shift bH 64);
== {lemma_mul_distribute_right (shift aH 64) bL (shift bH 64)}
aL *. bL +. aL *. shift bH 64 +. (shift aH 64 *. bL +. shift aH 64 *. shift bH 64);
== {lemma_add_all ()}
aL *. bL +. (aL *. shift bH 64 +. shift aH 64 *. bL) +. shift aH 64 *. shift bH 64;
== {lemma_shift_is_mul aH 64; lemma_shift_is_mul bH 64}
aL *. bL +. (aL *. (bH *. monomial 64) +. aH *. monomial 64 *. bL) +. aH *. monomial 64 *. (bH *. monomial 64);
== {lemma_mul_all ()}
aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. (monomial 64 *. monomial 64);
== {lemma_mul_monomials 64 64}
aL *. bL +. (aL *. bH *. monomial 64 +. aH *. bL *. monomial 64) +. aH *. bH *. monomial 128;
== {lemma_mul_distribute_left (aL *. bH) (aH *. bL) (monomial 64)}
aL *. bL +. (aL *. bH +. aH *. bL) *. monomial 64 +. aH *. bH *. monomial 128;
== {lemma_shift_is_mul (aL *. bH +. aH *. bL) 64; lemma_shift_is_mul (aH *. bH) 128}
aL *. bL +. shift (aL *. bH +. aH *. bL) 64 +. shift (aH *. bH) 128;
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 +. aL *. bH +. aH *. bL) 64 +. shift (z2 +. aH *. bH) 128
)) | [] | 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 +. Vale.Math.Poly2_s.shift z1 64 +. Vale.Math.Poly2_s.shift z2 128 in
let aL = Vale.Math.Poly2.mask a 64 in
let bL = Vale.Math.Poly2.mask b 64 in
let aH = Vale.Math.Poly2_s.shift a (- 64) in
let bH = Vale.Math.Poly2_s.shift b (- 64) in
z +. a *. b ==
z0 +. aL *. bL +. Vale.Math.Poly2_s.shift (z1 +. aL *. bH +. aH *. bL) 64 +.
Vale.Math.Poly2_s.shift (z2 +. aH *. bH) 128)) | {
"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_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
} | 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_odd_reverse_shift_right_lo_shift 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) *. 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) nn1) (shift (reverse ah nn1) (- n))) }
shift (reverse ah nn1) (- n);
( == ) { lemma_mul_odd_reverse_shift_right a h n }
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (- 1)) n1) (- n);
( == ) { lemma_shift_is_mul (reverse a n1) n }
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (- 1)) n1) (- n);
( == ) { (lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (- 1)) n1) (- n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (- 1)) n1) (- n))) }
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (- 1)) n1) (- n);
( == ) { lemma_shift_is_div (reverse a n1 *. reverse (shift h (- 1)) n1) n }
reverse a n1 +. (reverse a n1 *. reverse (shift h (- 1)) n1) /. m;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Math.Poly2.mask",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.Lemmas.lemma_mask_is_mod",
"Vale.Math.Poly2.lemma_shift_is_mul",
"Prims.squash",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Vale.AES.GF128.lemma_mul_odd_reverse_shift_right",
"Vale.Math.Poly2.Lemmas.lemma_shift_is_div",
"Vale.Math.Poly2_s.monomial",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Addition"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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
)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (a *. h %. m *. m) (n + n - 1) ==
Vale.Math.Poly2_s.reverse a n1 +.
Vale.Math.Poly2_s.reverse a n1 *.
Vale.Math.Poly2_s.reverse (Vale.Math.Poly2_s.shift h (- 1)) n1 /.
m)) | {
"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_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 (reverse ah nn1) n)}
mask (reverse ah nn1) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
} | 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) n;
( == ) { lemma_mask_is_mod (reverse ah nn1) n }
reverse ah nn1 %. m;
( == ) { lemma_mul_odd_reverse_shift_right a h n }
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (- 1)) n1) %. m;
( == ) { lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (- 1)) n1) m }
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (- 1)) n1) %. m;
( == ) { lemma_div_mod_exact (reverse a n1) m }
zero +. (reverse a n1 *. reverse (shift h (- 1)) n1) %. m;
( == ) { lemma_add_all () }
(reverse a n1 *. reverse (shift h (- 1)) n1) %. m;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.zero",
"Vale.Math.Poly2.mask",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.Lemmas.lemma_shift_is_div",
"Prims.squash",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Vale.Math.Poly2.Lemmas.lemma_mask_is_mod",
"Vale.AES.GF128.lemma_mul_odd_reverse_shift_right",
"Vale.Math.Poly2.Lemmas.lemma_mod_distribute",
"Vale.Math.Poly2.Lemmas.lemma_div_mod_exact",
"Vale.Math.Poly2.Lemmas.lemma_add_all",
"Vale.Math.Poly2_s.monomial",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Addition"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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
)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (a *. h /. m) n1 ==
Vale.Math.Poly2_s.reverse a n1 *.
Vale.Math.Poly2_s.reverse (Vale.Math.Poly2_s.shift h (- 1)) n1 %.
m)) | {
"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
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 64) 64 in
let y_0 = mask y_10 64 in
let y_10c = swap y_10 64 +. y_0 *. c in
let a = a0 +. shift a1 64 +. shift a2 128 in
let x = reverse a (nn + nn - 1) in
reverse (x %. g) (nn - 1) == swap y_10c 64 +. (a2 +. shift a1 (-64)) +. mask y_10c 64 *. 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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 = 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 +. 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
x %. g;
== {
lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)
}
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
== {lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g}
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
== {lemma_mod_small (x0 +. shift x1 n) g}
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc (==) {
rev (x %. g);
== {
lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))
}
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
== {lemma_add_commute x2 (shift x3 n); lemma_shift_is_mul (x2 +. shift x3 n) nn; lemma_shift_is_mul x3 n}
rev (x0 +. shift x1 n) +. rev (x32 %. g);
== {lemma_reduce_rev_hi x3 x2 h n}
rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
== {lemma_reduce_rev_bits a0 a1 a2 c n}
swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c;
} | 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
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 64) 64 in
let y_0 = mask y_10 64 in
let y_10c = swap y_10 64 +. y_0 *. c in
let a = a0 +. shift a1 64 +. shift a2 128 in
let x = reverse a (nn + nn - 1) in
reverse (x %. g) (nn - 1) == swap y_10c 64 +. (a2 +. shift a1 (-64)) +. mask y_10c 64 *. c
))
let lemma_reduce_rev a0 a1 a2 h n = | 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 +. 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)) n in
let x2 = mask (shift x (- nn)) n in
let x3 = shift x (- nnn) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc ( == ) {
x %. g;
( == ) { (lemma_bitwise_all ();
lemma_equal x ((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn)) }
((x0 +. shift x1 n) +. shift (x2 +. shift x3 n) nn) %. g;
( == ) { lemma_mod_distribute (x0 +. shift x1 n) (shift (x2 +. shift x3 n) nn) g }
(x0 +. shift x1 n) %. g +. shift (x2 +. shift x3 n) nn %. g;
( == ) { lemma_mod_small (x0 +. shift x1 n) g }
x0 +. shift x1 n +. shift (x2 +. shift x3 n) nn %. g;
};
calc ( == ) {
rev (x %. g);
( == ) { (lemma_bitwise_all ();
lemma_equal (rev (x %. g)) (rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g))) }
rev (x0 +. shift x1 n) +. rev (shift (x2 +. shift x3 n) nn %. g);
( == ) { (lemma_add_commute x2 (shift x3 n);
lemma_shift_is_mul (x2 +. shift x3 n) nn;
lemma_shift_is_mul x3 n) }
rev (x0 +. shift x1 n) +. rev (x32 %. g);
( == ) { lemma_reduce_rev_hi x3 x2 h n }
rev (x0 +. shift x1 n) +.
((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n));
( == ) { lemma_reduce_rev_bits a0 a1 a2 c n }
swap y_10c n +. (a2 +. shift a1 (- n)) +. mask y_10c n *. c;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Prims.squash",
"Vale.Math.Poly2.lemma_shift_is_mul",
"Vale.Math.Poly2.lemma_add_commute",
"Vale.AES.GF128.lemma_reduce_rev_hi",
"Vale.AES.GF128.lemma_reduce_rev_bits",
"Vale.Math.Poly2.Lemmas.lemma_mod_distribute",
"Vale.Math.Poly2.Lemmas.lemma_mod_small",
"Vale.Math.Poly2_s.reverse",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Vale.Math.Poly2_s.monomial",
"Prims.int"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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
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 64) 64 in
let y_0 = mask y_10 64 in
let y_10c = swap y_10 64 +. y_0 *. c in
let a = a0 +. shift a1 64 +. shift a2 128 in
let x = reverse a (nn + nn - 1) in
reverse (x %. g) (nn - 1) == swap y_10c 64 +. (a2 +. shift a1 (-64)) +. mask y_10c 64 *. c
)) | [] | 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.degree a2 < n + n /\
Vale.Math.Poly2_s.degree (Vale.Math.Poly2_s.monomial (n + n) +. h) == n + n /\
Vale.Math.Poly2_s.degree h < n /\ h.[ 0 ])
(ensures
(let nn = n + n in
let mm = Vale.Math.Poly2_s.monomial nn in
let m = Vale.Math.Poly2_s.monomial n in
let g = mm +. h in
let c = Vale.Math.Poly2_s.reverse (Vale.Math.Poly2_s.shift h (- 1)) (n - 1) in
let y_10 = a0 +. Vale.Math.Poly2_s.shift (Vale.Math.Poly2.mask a1 64) 64 in
let y_0 = Vale.Math.Poly2.mask y_10 64 in
let y_10c = Vale.Math.Poly2.swap y_10 64 +. y_0 *. c in
let a = a0 +. Vale.Math.Poly2_s.shift a1 64 +. Vale.Math.Poly2_s.shift a2 128 in
let x = Vale.Math.Poly2_s.reverse a (nn + nn - 1) in
Vale.Math.Poly2_s.reverse (x %. g) (nn - 1) ==
Vale.Math.Poly2.swap y_10c 64 +. (a2 +. Vale.Math.Poly2_s.shift a1 (- 64)) +.
Vale.Math.Poly2.mask y_10c 64 *. c)) | {
"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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_quad32_vec_equal (to_quad32 (shift a 1)) (quad32_shift_left_1 (to_quad32 a));
() | 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_shift_left_1 (to_quad32 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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.lemma_reverse_define_all",
"Vale.Math.Poly2.Lemmas.lemma_shift_define",
"Vale.Math.Poly2.Lemmas.lemma_index_all",
"Vale.Arch.TypesNative.lemma_ixor_nth_all",
"Vale.Arch.TypesNative.lemma_ishr_nth_all",
"Vale.Arch.TypesNative.lemma_ishl_nth_all",
"Vale.Arch.TypesNative.lemma_zero_nth",
"Vale.Math.Poly2.Bits_s.reveal_to_quad32"
] | [] | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) 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)) n in
let x2 = mask (shift x (- nn)) n in
let x3 = shift x (- nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +.
((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (- n)) +. mask y_10c n *. 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": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c)
))
=
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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc (==) {
y0;
== {lemma_bitwise_all (); lemma_equal y0 y_0}
y_0;
};
calc (==) {
shift y1 n +. y0;
== {lemma_bitwise_all (); lemma_equal (shift y1 n +. y0) y_10}
y_10;
};
calc (==) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
== {lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64}
swap (swap y_10 n +. y_0 *. c) n;
};
calc (==) {
rev (x0 +. shift x1 n);
== {lemma_bitwise_all (); lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (-n))}
a2 +. shift a1 (-n);
};
calc (==) {
y1 +. mask (y0 *. c) n;
== {lemma_bitwise_all (); lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)}
mask y_10c n;
};
calc (==) {
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
== {lemma_add_all ()}
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
} | 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) 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)) n in
let x2 = mask (shift x (- nn)) n in
let x3 = shift x (- nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +.
((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (- n)) +. mask y_10c n *. c)))
let 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) 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)) n in
let x2 = mask (shift x (- nn)) n in
let x3 = shift x (- nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +.
((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (- n)) +. mask y_10c n *. c))) = | 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)) n in
let x2 = mask (shift x (- nn)) n in
let x3 = shift x (- nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
calc ( == ) {
y0;
( == ) { (lemma_bitwise_all ();
lemma_equal y0 y_0) }
y_0;
};
calc ( == ) {
shift y1 n +. y0;
( == ) { (lemma_bitwise_all ();
lemma_equal (shift y1 n +. y0) y_10) }
y_10;
};
calc ( == ) {
(shift y1 n +. y0 +. swap (y0 *. c) n);
( == ) { lemma_swap_right (shift y1 n +. y0) (y0 *. c) 64 }
swap (swap y_10 n +. y_0 *. c) n;
};
calc ( == ) {
rev (x0 +. shift x1 n);
( == ) { (lemma_bitwise_all ();
lemma_equal (rev (x0 +. shift x1 n)) (a2 +. shift a1 (- n))) }
a2 +. shift a1 (- n);
};
calc ( == ) {
y1 +. mask (y0 *. c) n;
( == ) { (lemma_bitwise_all ();
lemma_equal (y1 +. mask (y0 *. c) n) (mask y_10c n)) }
mask y_10c n;
};
calc ( == ) {
(rev (x0 +. shift x1 n) +.
((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)));
( == ) { lemma_add_all () }
(shift y1 n +. y0 +. swap (y0 *. c) n) +. rev (x0 +. shift x1 n) +. (y1 +. mask (y0 *. c) n) *. c;
} | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Math.Poly2.Lemmas.lemma_add_all",
"Prims.squash",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Prims.op_Minus",
"Vale.AES.GF128.lemma_swap_right",
"Vale.Math.Poly2_s.reverse",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Prims.int",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Math.Poly2_s.degree",
"FStar.Pervasives.pattern"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
}
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
let lemma_swap_right (a b:poly) (n:nat) : Lemma
(requires n == 64 /\ degree a < n + n /\ degree b < n + n)
(ensures swap (swap a n +. b) n == a +. swap b n)
=
lemma_bitwise_all ();
lemma_equal (swap (swap a n +. b) n) (a +. swap b n)
#reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
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 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)) n in
let x2 = mask (shift x (-nn)) n in
let x3 = shift x (-nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +. ((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (-n)) +. mask y_10c n *. c) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) 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)) n in
let x2 = mask (shift x (- nn)) n in
let x3 = shift x (- nnn) in
let y0 = reverse x3 n1 in
let y1 = reverse x2 n1 in
(rev (x0 +. shift x1 n) +.
((y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n))) ==
(swap y_10c n +. (a2 +. shift a1 (- n)) +. mask y_10c n *. c))) | [] | 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.degree a2 < n + n /\ Vale.Math.Poly2_s.degree c < n)
(ensures
(let n1 = n - 1 in
let nn = n + n in
let nnn = nn + n in
let rev a = Vale.Math.Poly2_s.reverse a (nn - 1) in
let y_10 = a0 +. Vale.Math.Poly2_s.shift (Vale.Math.Poly2.mask a1 n) n in
let y_0 = Vale.Math.Poly2.mask y_10 n in
let y_10c = Vale.Math.Poly2.swap y_10 n +. y_0 *. c in
let a = a0 +. Vale.Math.Poly2_s.shift a1 n +. Vale.Math.Poly2_s.shift a2 nn in
let x = Vale.Math.Poly2_s.reverse a (nn + nn - 1) in
let x0 = Vale.Math.Poly2.mask x n in
let x1 = Vale.Math.Poly2.mask (Vale.Math.Poly2_s.shift x (- n)) n in
let x2 = Vale.Math.Poly2.mask (Vale.Math.Poly2_s.shift x (- nn)) n in
let x3 = Vale.Math.Poly2_s.shift x (- nnn) in
let y0 = Vale.Math.Poly2_s.reverse x3 n1 in
let y1 = Vale.Math.Poly2_s.reverse x2 n1 in
rev (x0 +. Vale.Math.Poly2_s.shift x1 n) +.
((y1 +. Vale.Math.Poly2.mask (y0 *. c) n) *. c +.
(Vale.Math.Poly2_s.shift y1 n +. y0 +. Vale.Math.Poly2.swap (y0 *. c) n)) ==
Vale.Math.Poly2.swap y_10c n +. (a2 +. Vale.Math.Poly2_s.shift a1 (- n)) +.
Vale.Math.Poly2.mask y_10c n *. c)) | {
"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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) 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": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 *. h in
let x3hl = x3h %. m in
let x3hh = x3h /. m in
lemma_index_i h 0;
calc (==) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
== {lemma_mod_reduce (x3 *. m +. x2) mm h}
((x3 *. m +. x2) *. h) %. (mm +. h);
== {lemma_mul_distribute_left (x3 *. m) x2 h}
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
== {lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
== {lemma_mod_small (x2 *. h) (mm +. h)}
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
== {lemma_mul_all ()}
(x3h *. m) %. (mm +. h) +. x2 *. h;
== {lemma_div_mod x3h m}
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mul_distribute_left (x3hh *. m) x3hl m}
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
== {lemma_mod_small (x3hl *. m) (mm +. h)}
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_associate x3hh m m}
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mul_monomials n n}
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_reduce x3hh mm h}
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
== {lemma_mod_small (x3hh *. h) (mm +. h)}
x3hh *. h +. (x3hl *. m) +. x2 *. h;
== {lemma_add_all ()}
x3hh *. h +. x2 *. h +. (x3hl *. m);
== {lemma_mul_distribute_left x3hh x2 h}
(x3hh +. x2) *. h +. x3hl *. m;
};
calc (==) {
reverse (x32 %. g) nn1;
== {
// use the calc result from above (could put nested calc here, but it's slower)
}
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
== {lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1}
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
== {lemma_mul_odd_reverse_shift_right_lo_shift x3 h n}
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n}
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_add_reverse x3hh x2 n1}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left (reverse x3hh n1) y1 c}
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_odd_reverse_shift_right_hi x3 h n}
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
== {lemma_mul_distribute_left ((y0 *. c) %. m) y1 c}
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
== {
lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n
}
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (-n));
== {lemma_add_all ()}
(y1 +. mask (y0 *. c) n) *. c +. (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)));
== {
lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (-n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)
}
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n);
} | 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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
))
let lemma_reduce_rev_hi x3 x2 h n = | 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
lemma_index_i h 0;
calc ( == ) {
((x3 *. m +. x2) *. mm) %. (mm +. h);
( == ) { lemma_mod_reduce (x3 *. m +. x2) mm h }
((x3 *. m +. x2) *. h) %. (mm +. h);
( == ) { lemma_mul_distribute_left (x3 *. m) x2 h }
(x3 *. m *. h +. x2 *. h) %. (mm +. h);
( == ) { lemma_mod_distribute (x3 *. m *. h) (x2 *. h) (mm +. h) }
(x3 *. m *. h) %. (mm +. h) +. (x2 *. h) %. (mm +. h);
( == ) { lemma_mod_small (x2 *. h) (mm +. h) }
(x3 *. m *. h) %. (mm +. h) +. x2 *. h;
( == ) { lemma_mul_all () }
(x3h *. m) %. (mm +. h) +. x2 *. h;
( == ) { lemma_div_mod x3h m }
((x3hh *. m +. x3hl) *. m) %. (mm +. h) +. x2 *. h;
( == ) { lemma_mul_distribute_left (x3hh *. m) x3hl m }
(x3hh *. m *. m +. x3hl *. m) %. (mm +. h) +. x2 *. h;
( == ) { lemma_mod_distribute (x3hh *. m *. m) (x3hl *. m) (mm +. h) }
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) %. (mm +. h) +. x2 *. h;
( == ) { lemma_mod_small (x3hl *. m) (mm +. h) }
(x3hh *. m *. m) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
( == ) { lemma_mul_associate x3hh m m }
(x3hh *. (m *. m)) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
( == ) { lemma_mul_monomials n n }
(x3hh *. mm) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
( == ) { lemma_mod_reduce x3hh mm h }
(x3hh *. h) %. (mm +. h) +. (x3hl *. m) +. x2 *. h;
( == ) { lemma_mod_small (x3hh *. h) (mm +. h) }
x3hh *. h +. (x3hl *. m) +. x2 *. h;
( == ) { lemma_add_all () }
x3hh *. h +. x2 *. h +. (x3hl *. m);
( == ) { lemma_mul_distribute_left x3hh x2 h }
(x3hh +. x2) *. h +. x3hl *. m;
};
calc ( == ) {
reverse (x32 %. g) nn1;
( == ) { () }
reverse ((x3hh +. x2) *. h +. x3hl *. m) nn1;
( == ) { lemma_add_reverse ((x3hh +. x2) *. h) (x3hl *. m) nn1 }
reverse ((x3hh +. x2) *. h) nn1 +. reverse (x3hl *. m) nn1;
( == ) { lemma_mul_odd_reverse_shift_right_lo_shift x3 h n }
reverse ((x3hh +. x2) *. h) nn1 +. (y0 +. (y0 *. c) /. m);
( == ) { lemma_mul_odd_reverse_shift_right (x3hh +. x2) h n }
reverse (x3hh +. x2) n1 *. m +. reverse (x3hh +. x2) n1 *. c +. (y0 +. (y0 *. c) /. m);
( == ) { lemma_add_reverse x3hh x2 n1 }
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 +. y1) *. c +. (y0 +. (y0 *. c) /. m);
( == ) { lemma_mul_distribute_left (reverse x3hh n1) y1 c }
(reverse x3hh n1 +. y1) *. m +. (reverse x3hh n1 *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
( == ) { lemma_mul_odd_reverse_shift_right_hi x3 h n }
((y0 *. c) %. m +. y1) *. m +. (((y0 *. c) %. m) *. c +. y1 *. c) +. (y0 +. (y0 *. c) /. m);
( == ) { lemma_mul_distribute_left ((y0 *. c) %. m) y1 c }
((y0 *. c) %. m +. y1) *. m +. ((y0 *. c) %. m +. y1) *. c +. (y0 +. (y0 *. c) /. m);
( == ) { (lemma_shift_is_div (y0 *. c) n;
lemma_mask_is_mod (y0 *. c) n;
lemma_shift_is_mul ((y0 *. c) %. m +. y1) n) }
shift (mask (y0 *. c) n +. y1) n +. (mask (y0 *. c) n +. y1) *. c +. (y0 +. shift (y0 *. c) (- n));
( == ) { lemma_add_all () }
(y1 +. mask (y0 *. c) n) *. c +.
(shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (- n)));
( == ) { (lemma_bitwise_all ();
lemma_equal (shift (mask (y0 *. c) n +. y1) n +. (y0 +. shift (y0 *. c) (- n)))
(shift y1 n +. y0 +. swap (y0 *. c) n)) }
(y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) 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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Minus",
"Vale.Math.Poly2.op_Slash_Dot",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Vale.Math.Poly2.Lemmas.lemma_add_reverse",
"Vale.AES.GF128.lemma_mul_odd_reverse_shift_right_lo_shift",
"Vale.AES.GF128.lemma_mul_odd_reverse_shift_right",
"Vale.Math.Poly2.Lemmas.lemma_mul_distribute_left",
"Vale.AES.GF128.lemma_mul_odd_reverse_shift_right_hi",
"Vale.Math.Poly2.lemma_shift_is_mul",
"Vale.Math.Poly2.Lemmas.lemma_mask_is_mod",
"Vale.Math.Poly2.Lemmas.lemma_shift_is_div",
"Vale.Math.Poly2.Lemmas.lemma_add_all",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2.Lemmas.lemma_bitwise_all",
"Vale.Math.Poly2.Lemmas.lemma_mod_reduce",
"Vale.Math.Poly2.Lemmas.lemma_mod_distribute",
"Vale.Math.Poly2.Lemmas.lemma_mod_small",
"Vale.Math.Poly2.Lemmas.lemma_mul_all",
"Vale.Math.Poly2.lemma_div_mod",
"Vale.Math.Poly2.lemma_mul_associate",
"Vale.Math.Poly2.Lemmas.lemma_mul_monomials",
"Vale.Math.Poly2.lemma_index_i",
"Vale.Math.Poly2_s.monomial",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Addition"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
()
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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
()
#reset-options
let lemma_reverse_reverse a n =
lemma_reverse_define_all ();
lemma_index_all ();
lemma_equal a (reverse (reverse a n) n)
let lemma_gf128_degree () =
lemma_add_define_all ();
lemma_monomial_define 128;
lemma_degree_is gf128_modulus_low_terms 7;
lemma_degree_is (monomial 128) 128;
lemma_degree_is gf128_modulus 128;
()
let lemma_gf128_constant_rev q =
let n0:nat32 = 0 in
let n1:nat32 = 0 in
let n2:nat32 = 0 in
let n3:nat32 = 0xe1000000 in
calc (==) {
Mkfour n0 n1 n2 n3;
== {lemma_quad32_of_nat32s n0 n1 n2 n3}
to_quad32 (poly128_of_nat32s n0 n1 n2 n3);
== {
lemma_bitwise_all ();
lemma_to_nat 32 (reverse gf128_modulus_low_terms 31) 0xe1000000;
lemma_equal (poly128_of_nat32s n0 n1 n2 n3) (reverse gf128_modulus_low_terms 127)
}
to_quad32 (reverse gf128_modulus_low_terms 127);
};
Vale.Arch.Types.lemma_quad32_xor ()
let lemma_quad32_double_hi_rev a =
let ra = reverse a 127 in
lemma_split_define ra 64;
lemma_split_define_forward a 64;
lemma_index_all ();
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_equal (a /. monomial 64) (reverse ra 63);
lemma_quad32_double a
let lemma_gf128_mul a b c d n =
let m = monomial n in
let ab = a *. m +. b in
let cd = c *. m +. d in
let ac = a *. c in
let ad = a *. d in
let bc = b *. c in
let bd = b *. d in
let adh = ad /. m in
let bch = bc /. m in
let adl = ad %. m in
let bcl = bc %. m in
// ab *. cd
// (a *. m +. b) *. (c *. m +. d)
lemma_mul_distribute_right (a *. m +. b) (c *. m) d;
lemma_mul_distribute_left (a *. m) b (c *. m);
lemma_mul_distribute_left (a *. m) b d;
// ((a *. m) *. (c *. m) +. b *. (c *. m)) +. ((a *. m) *. d +. b *. d);
lemma_mul_associate b c m;
lemma_mul_associate a m d;
lemma_mul_commute m d;
lemma_mul_associate a d m;
lemma_mul_associate a m (c *. m);
lemma_mul_associate m c m;
lemma_mul_commute c m;
lemma_mul_associate c m m;
lemma_mul_associate a c (m *. m);
// (ac *. (m *. m) +. bc *. m) +. (ad *. m +. bd)
lemma_div_mod ad m;
lemma_div_mod bc m;
// (ac *. (m *. m) +. (bch *. m +. bcl) *. m) +. ((adh *. m +. adl) *. m +. bd)
lemma_mul_distribute_left (bch *. m) bcl m;
lemma_mul_distribute_left (adh *. m) adl m;
// (ac *. (m *. m) +. (bch *. m *. m +. bcl *. m)) +. ((adh *. m *. m +. adl *. m) +. bd)
lemma_mul_associate bch m m;
lemma_mul_associate adh m m;
// (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd)
assert (ab *. cd == (ac *. (m *. m) +. (bch *. (m *. m) +. bcl *. m)) +. ((adh *. (m *. m) +. adl *. m) +. bd));
lemma_add_define_all ();
lemma_equal (ab *. cd) ((ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd));
// (ac *. (m *. m) +. bch *. (m *. m) +. adh *. (m *. m)) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_distribute_left ac bch (m *. m);
lemma_mul_distribute_left (ac +. bch) adh (m *. m);
// (ac +. bch +. adh) *. (m *. m) +. (bcl *. m +. adl *. m +. bd)
lemma_mul_monomials n n;
lemma_shift_is_mul (ac +. bch +. adh) (n + n);
// shift (ac +. bch +. adh) (n + n) +. (bcl *. m +. adl *. m +. bd)
()
let lemma_gf128_reduce a b g n h =
let ab = a *. b in
let d = ab /. n in
let m = ab %. n in
let dh = d *. h in
let d' = dh /. n in
let m' = dh %. n in
lemma_div_mod ab n;
lemma_div_mod dh n;
// ab == d *. n +. m
// dh == d' *. n +. m'
// ab % g
// (d *. n +. m) % g
lemma_add_define_all ();
lemma_zero_define ();
lemma_equal n (g +. h);
// (d *. (g +. h) +. m) % g
lemma_mul_distribute_right d g h;
// (d *. g +. dh +. m) % g
// (d *. g +. (d' *. n +. m') + m) % g
// (d *. g +. (d' *. (g +. h) +. m') + m) % g
lemma_mul_distribute_right d' g h;
// (d *. g +. (d' *. g +. d' *. h +. m') + m) % g
lemma_equal ab ((d *. g +. d' *. g) +. (d' *. h +. m' +. m));
lemma_mul_distribute_left d d' g;
// ((d +. d') *. g +. (d' *. h +. m' +. m)) % g
lemma_mod_distribute ((d +. d') *. g) (d' *. h +. m' +. m) g;
lemma_div_mod_exact (d +. d') g;
lemma_equal (ab %. g) ((d' *. h +. m' +. m) %. g);
// (d' *. h +. m' +. m) % g
lemma_mod_small (d' *. h +. m' +. m) g;
// d' *. h +. m' +. m
()
#reset-options "--max_ifuel 0"
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 rd *. h) in
let rdhL = rdh %. m in
let rdhLh = r (r rdhL *. h) in
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_index_all ();
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (r rd) d;
lemma_split_define ab n;
lemma_split_define_forward rab n;
lemma_equal (rab /. m) (r (ab %. m));
lemma_split_define dh n;
lemma_split_define_forward rdh n;
lemma_equal (rdh /. m) (r (dh %. m));
lemma_equal (r rdhL) (dh /. m);
lemma_equal rdhLh (r ((dh /. m) *. h));
lemma_equal (r ((a *. b) %. g)) (r ((dh /. m) *. h) +. r (dh %. m) +. r ((a *. b) %. m));
()
val lemma_odd_reverse_shift_right (a:poly) (n:pos) : Lemma
(requires degree a < n /\ a.[0])
(ensures shift (reverse a (n - 1)) 1 == monomial n +. reverse (shift a (-1)) (n - 1))
let lemma_odd_reverse_shift_right a n =
lemma_bitwise_all ();
lemma_equal (shift (reverse a (n - 1)) 1) (monomial n +. reverse (shift a (-1)) (n - 1))
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 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 1 *. (reverse a n1 *. reverse h n1);
== {lemma_mul_all ()}
reverse a n1 *. (monomial 1 *. reverse h n1);
== {lemma_shift_is_mul_left (reverse h n1) 1}
reverse a n1 *. shift (reverse h n1) 1;
== {lemma_odd_reverse_shift_right h n}
reverse a n1 *. (m +. reverse (shift h (-1)) n1);
== {lemma_mul_distribute_right (reverse a n1) m (reverse (shift h (-1)) n1)}
reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1;
}
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 =
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) n;
== {lemma_mask_is_mod (reverse ah nn1) n}
reverse ah nn1 %. m;
== {lemma_mul_odd_reverse_shift_right a h n}
(reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_mod_distribute (reverse a n1 *. m) (reverse a n1 *. reverse (shift h (-1)) n1) m}
(reverse a n1 *. m) %. m +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_div_mod_exact (reverse a n1) m}
zero +. (reverse a n1 *. reverse (shift h (-1)) n1) %. m;
== {lemma_add_all ()}
(reverse a n1 *. reverse (shift h (-1)) n1) %. m;
}
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_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_bitwise_all ();
lemma_equal (reverse (shift (mask ah n) n) nn1) (shift (reverse ah nn1) (-n))
}
shift (reverse ah nn1) (-n);
== {lemma_mul_odd_reverse_shift_right a h n}
shift (reverse a n1 *. m +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_mul (reverse a n1) n}
shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {
lemma_bitwise_all ();
lemma_equal (shift (shift (reverse a n1) n +. reverse a n1 *. reverse (shift h (-1)) n1) (-n))
(reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n))
}
reverse a n1 +. shift (reverse a n1 *. reverse (shift h (-1)) n1) (-n);
== {lemma_shift_is_div (reverse a n1 *. reverse (shift h (-1)) n1) n}
reverse a n1 +. (reverse a n1 *. reverse (shift h (-1)) n1) /. m;
}
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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 = reverse (shift h (-1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = reverse x3 (n - 1) in
let y1 = reverse x2 (n - 1) in
reverse (x32 %. g) (nn - 1) == (y1 +. mask (y0 *. c) n) *. c +. (shift y1 n +. y0 +. swap (y0 *. c) n)
)) | [] | 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 + n /\
Vale.Math.Poly2_s.degree h < n /\ h.[ 0 ])
(ensures
(let nn = n + n in
let mm = Vale.Math.Poly2_s.monomial nn in
let m = Vale.Math.Poly2_s.monomial n in
let g = mm +. h in
let c = Vale.Math.Poly2_s.reverse (Vale.Math.Poly2_s.shift h (- 1)) (n - 1) in
let x32 = (x3 *. m +. x2) *. mm in
let y0 = Vale.Math.Poly2_s.reverse x3 (n - 1) in
let y1 = Vale.Math.Poly2_s.reverse x2 (n - 1) in
Vale.Math.Poly2_s.reverse (x32 %. g) (nn - 1) ==
(y1 +. Vale.Math.Poly2.mask (y0 *. c) n) *. c +.
(Vale.Math.Poly2_s.shift y1 n +. y0 +. Vale.Math.Poly2.swap (y0 *. c) 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 (a' /. 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": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_ishl_nth_all 32;
lemma_ishr_nth_all 32;
lemma_ixor_nth_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
() | 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 (a' /. n)
))
let lemma_shift_2_left_1 lo hi = | 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_all 32;
lemma_index_all ();
lemma_shift_define a 1;
lemma_add_define_all ();
lemma_reverse_define_all ();
lemma_div_mod a' n;
lemma_shift_is_mul hi 128;
lemma_shift_define hi 128;
lemma_shift_is_mul (a' /. n) 128;
let lemma_lo () : Lemma (qlo' == to_quad32 (a' %. n)) =
lemma_shift_define (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qlo' (to_quad32 (a' %. n))
in
let lemma_hi () : Lemma (qhi' == to_quad32 (a' /. n)) =
lemma_shift_define_forward (a' /. n) 128;
quad32_xor_reveal ();
reverse_bytes_nat32_reveal ();
lemma_quad32_vec_equal qhi' (to_quad32 (a' /. n))
in
lemma_lo ();
lemma_hi ();
() | {
"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"
],
"interface_file": true,
"source_file": "Vale.AES.GF128.fst"
} | [
"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",
"Vale.Def.Types_s.reverse_bytes_nat32_reveal",
"Vale.Def.Types_s.quad32_xor_reveal",
"Vale.Math.Poly2.Lemmas.lemma_shift_define_forward",
"Vale.Math.Poly2_s.mod",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.Lemmas.lemma_shift_define",
"Vale.Math.Poly2.lemma_shift_is_mul",
"Vale.Math.Poly2.lemma_div_mod",
"Vale.Math.Poly2.Lemmas.lemma_reverse_define_all",
"Vale.Math.Poly2.Lemmas.lemma_add_define_all",
"Vale.Math.Poly2.Lemmas.lemma_index_all",
"Vale.Arch.TypesNative.lemma_ixor_nth_all",
"Vale.Arch.TypesNative.lemma_ishr_nth_all",
"Vale.Arch.TypesNative.lemma_ishl_nth_all",
"Vale.Arch.TypesNative.lemma_zero_nth",
"Vale.Math.Poly2.Bits_s.reveal_to_quad32",
"FStar.Pervasives.Native.tuple2",
"Vale.AES.GF128.quad32_shift_2_left_1",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.op_Star_Dot",
"Vale.Math.Poly2_s.monomial"
] | [] | 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 ();
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_shift_left_1 (to_quad32 a));
() | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (a' /. n)
)) | [] | 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 in
let _ =
Vale.AES.GF128.quad32_shift_2_left_1 (Vale.Math.Poly2.Bits_s.to_quad32 lo)
(Vale.Math.Poly2.Bits_s.to_quad32 hi)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ lo' hi' = _ in
lo' == Vale.Math.Poly2.Bits_s.to_quad32 (a' %. n) /\
hi' == Vale.Math.Poly2.Bits_s.to_quad32 (a' /. n))
<:
Type0)) | {
"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": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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
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
let new_bn_from_bytes_be r len b =
BS.new_bn_from_bytes_be r len b | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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
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
let new_bn_from_bytes_be r len b =
BS.new_bn_from_bytes_be r len b
let new_bn_from_bytes_le r len b =
BS.new_bn_from_bytes_le r len b
let bn_to_bytes_be len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_be false len b res
let bn_to_bytes_le len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_le false len b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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
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
let new_bn_from_bytes_be r len b =
BS.new_bn_from_bytes_be r len b
let new_bn_from_bytes_le r len b =
BS.new_bn_from_bytes_le r len b
let bn_to_bytes_be len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_be false len b res
let bn_to_bytes_le len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_le false len b res
let lt_mask len a b =
BN.bn_lt_mask len a b | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.AlmostMontgomery",
"short_module": "AM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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.__proj__Mkexp__item__exp_vt_precomp",
"Hacl.Bignum32.ke",
"Prims.unit",
"Hacl.Bignum.MontArithmetic.bn_field_get_len"
] | [] | 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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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__precomp",
"Hacl.Bignum32.kam",
"Hacl.Bignum32.bn_slow_precomp",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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_precomp",
"Prims.unit",
"Hacl.Bignum.MontArithmetic.bn_field_get_len"
] | [] | 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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.SafeAPI.mk_bn_mod_exp_safe",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_check",
"Hacl.Bignum32.ke",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_vt",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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_bn_mod_exp_ctx",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_vt_precomp",
"Hacl.Bignum32.ke",
"Prims.unit",
"Hacl.Bignum.MontArithmetic.bn_field_get_len"
] | [] | 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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.SafeAPI.mk_bn_mod_exp_safe",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_check",
"Hacl.Bignum32.ke",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_ct",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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_bn_mod_exp_ctx",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__exp_ct_precomp",
"Hacl.Bignum32.ke",
"Prims.unit",
"Hacl.Bignum.MontArithmetic.bn_field_get_len"
] | [] | 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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Convert.mk_bn_to_bytes_be",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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
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
let new_bn_from_bytes_be r len b =
BS.new_bn_from_bytes_be r len b
let new_bn_from_bytes_le r len b =
BS.new_bn_from_bytes_le r len b | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Bignum.Convert.bn_to_bytes_be_st Hacl.Bignum32.t_limbs len | {
"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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": true,
"full_module": "Hacl.Bignum.ModReduction",
"short_module": "BR"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum32.fst"
} | [
"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.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Convert.mk_bn_to_bytes_le",
"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 0 --ifuel 0"
inline_for_extraction noextract
let kam (len:BN.meta_len t_limbs) =
AM.mk_runtime_almost_mont #t_limbs len
inline_for_extraction noextract
let ke (len:BN.meta_len t_limbs) =
BE.mk_runtime_exp #t_limbs len
let add len a b res =
(ke len).BE.bn.BN.add a b res
let sub len a b res =
(ke len).BE.bn.BN.sub a b res
let add_mod len n a b res =
(ke len).BE.bn.BN.add_mod_n n a b res
let sub_mod len n a b res =
(ke len).BE.bn.BN.sub_mod_n n a b res
let mul len a b res =
(ke len).BE.bn.BN.mul a b res
let sqr len a res =
(ke len).BE.bn.BN.sqr a res
[@CInline]
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)
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
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
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
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
let mont_ctx_init len r n =
MA.bn_field_init len (ke len).BE.precompr2 r n
let mont_ctx_free k =
MA.bn_field_free k
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
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
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
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
let new_bn_from_bytes_be r len b =
BS.new_bn_from_bytes_be r len b
let new_bn_from_bytes_le r len b =
BS.new_bn_from_bytes_le r len b
let bn_to_bytes_be len b res =
Hacl.Bignum.Convert.mk_bn_to_bytes_be false len b res | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Bignum.Convert.bn_to_bytes_le_st Hacl.Bignum32.t_limbs len | {
"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",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Transformers.Common.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.PeepHole.fsti"
} | [
"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 list of instructions
into (optionally) another list of instructions.
Usage:
let foo = peephole_transform foo_ph
let lemma_foo = lemma_peephole_transform foo_ph
*)
module Vale.Transformers.PeepHole
open Vale.Transformers.Common
open Vale.X64.Decls
open Vale.X64.Lemmas
open Vale.X64.StateLemmas
open Vale.Transformers.Common
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
module L = FStar.List.Tot
open Vale.Transformers.InstructionReorder // open so that we don't
// need to redefine things
// equivalence etc.
open Vale.X64.InsLemmas
/// Define what a peephole means, and what it means to be correct.
noeq
type pre_peephole = {
ph: list ins -> Tot (option (list ins)); // The actual peephole transformer
input_hint: pos; // The number of instructions it takes as input to transform
}
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)
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
type peephole = (p:pre_peephole{forall is s. {:pattern (peephole_correct p is s)}
peephole_correct p is s})
/// Now, for the pièce de résistance, functions that give you
/// something you can directly use as transformers!
val peephole_transform :
p:peephole ->
orig:va_code ->
va_transformation_result
val lemma_peephole_transform :
p:peephole ->
orig:va_code ->
transformed:va_code ->
va_s0:va_state -> va_sM:va_state -> va_fM:va_fuel ->
Ghost (va_state & va_fuel)
(requires (
(va_require_total transformed (peephole_transform p orig).result va_s0) /\
(va_get_ok va_s0) /\
(va_ensure_total orig va_s0 va_sM va_fM) /\
(va_get_ok va_sM)))
(ensures (fun (va_sM', va_fM') ->
(va_fM' == va_fM) /\
(Vale.Transformers.Common.equiv_states va_sM va_sM') /\
(va_ensure_total transformed va_s0 va_sM' va_fM') /\
(va_get_ok va_sM')))
/// Common useful lemmas/definitions | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Transformers.Common.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.PeepHole.fsti"
} | [
"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__item__ms_ok",
"Vale.Transformers.InstructionReorder.equiv_states",
"Vale.Transformers.PeepHole.eval_inss"
] | [] | (**
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 list of instructions
into (optionally) another list of instructions.
Usage:
let foo = peephole_transform foo_ph
let lemma_foo = lemma_peephole_transform foo_ph
*)
module Vale.Transformers.PeepHole
open Vale.Transformers.Common
open Vale.X64.Decls
open Vale.X64.Lemmas
open Vale.X64.StateLemmas
open Vale.Transformers.Common
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
module L = FStar.List.Tot
open Vale.Transformers.InstructionReorder // open so that we don't
// need to redefine things
// equivalence etc.
open Vale.X64.InsLemmas
/// Define what a peephole means, and what it means to be correct.
noeq
type pre_peephole = {
ph: list ins -> Tot (option (list ins)); // The actual peephole transformer
input_hint: pos; // The number of instructions it takes as input to transform
}
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) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Transformers.Common.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.PeepHole.fsti"
} | [
"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 list of instructions
into (optionally) another list of instructions.
Usage:
let foo = peephole_transform foo_ph
let lemma_foo = lemma_peephole_transform foo_ph
*)
module Vale.Transformers.PeepHole
open Vale.Transformers.Common
open Vale.X64.Decls
open Vale.X64.Lemmas
open Vale.X64.StateLemmas
open Vale.Transformers.Common
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
module L = FStar.List.Tot
open Vale.Transformers.InstructionReorder // open so that we don't
// need to redefine things
// equivalence etc.
open Vale.X64.InsLemmas
/// Define what a peephole means, and what it means to be correct.
noeq
type pre_peephole = {
ph: list ins -> Tot (option (list ins)); // The actual peephole transformer
input_hint: pos; // The number of instructions it takes as input to transform
} | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) /\
(s3 == update_operand64_preserve_flags'' dst v_fin s0 s0))) (ensures (equiv_states s2 s3)) | [
{
"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",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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) /\
(s3 == update_operand64_preserve_flags'' dst v_fin s0 s0)))
(ensures (
equiv_states s2 s3)) =
match dst with
| OReg r -> assert (equiv_states_ext s2 s3) | 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) /\
(s3 == update_operand64_preserve_flags'' dst v_fin s0 s0))) (ensures (equiv_states s2 s3))
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) /\
(s3 == update_operand64_preserve_flags'' dst v_fin s0 s0))) (ensures (equiv_states s2 s3)) = | 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.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Transformers.Common.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.PeepHole.fsti"
} | [
"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.Machine_Semantics_s.valid_dst_operand64",
"Prims.eq2",
"Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags''",
"Prims.squash",
"Vale.Transformers.InstructionReorder.equiv_states",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (**
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 list of instructions
into (optionally) another list of instructions.
Usage:
let foo = peephole_transform foo_ph
let lemma_foo = lemma_peephole_transform foo_ph
*)
module Vale.Transformers.PeepHole
open Vale.Transformers.Common
open Vale.X64.Decls
open Vale.X64.Lemmas
open Vale.X64.StateLemmas
open Vale.Transformers.Common
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
module L = FStar.List.Tot
open Vale.Transformers.InstructionReorder // open so that we don't
// need to redefine things
// equivalence etc.
open Vale.X64.InsLemmas
/// Define what a peephole means, and what it means to be correct.
noeq
type pre_peephole = {
ph: list ins -> Tot (option (list ins)); // The actual peephole transformer
input_hint: pos; // The number of instructions it takes as input to transform
}
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)
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
type peephole = (p:pre_peephole{forall is s. {:pattern (peephole_correct p is s)}
peephole_correct p is s})
/// Now, for the pièce de résistance, functions that give you
/// something you can directly use as transformers!
val peephole_transform :
p:peephole ->
orig:va_code ->
va_transformation_result
val lemma_peephole_transform :
p:peephole ->
orig:va_code ->
transformed:va_code ->
va_s0:va_state -> va_sM:va_state -> va_fM:va_fuel ->
Ghost (va_state & va_fuel)
(requires (
(va_require_total transformed (peephole_transform p orig).result va_s0) /\
(va_get_ok va_s0) /\
(va_ensure_total orig va_s0 va_sM va_fM) /\
(va_get_ok va_sM)))
(ensures (fun (va_sM', va_fM') ->
(va_fM' == va_fM) /\
(Vale.Transformers.Common.equiv_states va_sM va_sM') /\
(va_ensure_total transformed va_s0 va_sM' va_fM') /\
(va_get_ok va_sM')))
/// Common useful lemmas/definitions
let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x
#push-options "--z3rlimit 10 --initial_fuel 0 --max_fuel 0 --initial_ifuel 2 --max_ifuel 2 --z3cliopt smt.arith.nl=true"
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_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
get_heap_val64_reveal ()
#pop-options
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) /\
(s3 == update_operand64_preserve_flags'' dst v_fin s0 s0)))
(ensures ( | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) /\
(s3 == update_operand64_preserve_flags'' dst v_fin s0 s0))) (ensures (equiv_states s2 s3)) | [] | 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_s.nat64
-> FStar.Pervasives.Lemma
(requires
OReg? dst /\ Vale.X64.Machine_Semantics_s.valid_dst_operand64 dst s0 /\
s1 == Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags'' dst v s0 s0 /\
s2 == Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags'' dst v_fin s1 s1 /\
s3 == Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags'' dst v_fin s0 s0)
(ensures Vale.Transformers.InstructionReorder.equiv_states s2 s3) | {
"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",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
get_heap_val64_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))
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)) = | 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.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Transformers.Common.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.PeepHole.fsti"
} | [
"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_heap",
"Prims.bool",
"Vale.Arch.MachineHeap_s.valid_addr64",
"Prims.b2t",
"Vale.X64.Machine_Semantics_s.valid_dst_operand64",
"Prims.squash",
"Prims.l_and",
"Vale.X64.Machine_Semantics_s.valid_src_operand64_and_taint",
"Prims.eq2",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.eval_operand",
"Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags''",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (**
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 list of instructions
into (optionally) another list of instructions.
Usage:
let foo = peephole_transform foo_ph
let lemma_foo = lemma_peephole_transform foo_ph
*)
module Vale.Transformers.PeepHole
open Vale.Transformers.Common
open Vale.X64.Decls
open Vale.X64.Lemmas
open Vale.X64.StateLemmas
open Vale.Transformers.Common
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
module L = FStar.List.Tot
open Vale.Transformers.InstructionReorder // open so that we don't
// need to redefine things
// equivalence etc.
open Vale.X64.InsLemmas
/// Define what a peephole means, and what it means to be correct.
noeq
type pre_peephole = {
ph: list ins -> Tot (option (list ins)); // The actual peephole transformer
input_hint: pos; // The number of instructions it takes as input to transform
}
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)
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
type peephole = (p:pre_peephole{forall is s. {:pattern (peephole_correct p is s)}
peephole_correct p is s})
/// Now, for the pièce de résistance, functions that give you
/// something you can directly use as transformers!
val peephole_transform :
p:peephole ->
orig:va_code ->
va_transformation_result
val lemma_peephole_transform :
p:peephole ->
orig:va_code ->
transformed:va_code ->
va_s0:va_state -> va_sM:va_state -> va_fM:va_fuel ->
Ghost (va_state & va_fuel)
(requires (
(va_require_total transformed (peephole_transform p orig).result va_s0) /\
(va_get_ok va_s0) /\
(va_ensure_total orig va_s0 va_sM va_fM) /\
(va_get_ok va_sM)))
(ensures (fun (va_sM', va_fM') ->
(va_fM' == va_fM) /\
(Vale.Transformers.Common.equiv_states va_sM va_sM') /\
(va_ensure_total transformed va_s0 va_sM' va_fM') /\
(va_get_ok va_sM')))
/// Common useful lemmas/definitions
let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x
#push-options "--z3rlimit 10 --initial_fuel 0 --max_fuel 0 --initial_ifuel 2 --max_ifuel 2 --z3cliopt smt.arith.nl=true"
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' /\ | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3",
"smt.arith.nl=true"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 in
Vale.X64.Machine_Semantics_s.valid_src_operand64_and_taint o s' /\
Vale.X64.Machine_Semantics_s.eval_operand o s' == v)) | {
"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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (p ==> req_then s) /\ ((~ p) ==> req_else s))
(fun s0 x s1 -> (p ==> ens_then s0 x s1) /\ ((~ p) ==> ens_else s0 x s1))
[@@ primitive_extraction]
reflectable
effect {
MSTATE (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATE state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (p ==> req_then s) /\ ((~ p) ==> req_else s))
(fun s0 x s1 -> (p ==> ens_then s0 x s1) /\ ((~ p) ==> ens_else s0 x s1))
[@@ primitive_extraction]
reflectable
effect {
MSTATE (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
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)
[@@ noextract_to "krml"]
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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)
(req: pre_t state)
(ens: post_t state a)
(f: MSTTotal.repr a state rel req ens)
: repr a state rel req ens = | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (p ==> req_then s) /\ ((~ p) ==> req_else s))
(fun s0 x s1 -> (p ==> ens_then s0 x s1) /\ ((~ p) ==> ens_else s0 x s1))
[@@ primitive_extraction]
reflectable
effect {
MSTATE (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
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)
[@@ noextract_to "krml"]
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)
assume
val witness (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
: MSTATE (W.witnessed state rel p) state rel
(fun s0 -> p s0 /\ W.stable state rel p)
(fun s0 _ s1 -> s0 == s1)
assume
val recall (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
(w:W.witnessed state rel p)
: MSTATE unit state rel
(fun _ -> True)
(fun s0 _ s1 -> s0 == s1 /\ p s1)
(*
* AR: why do we need the first conjunct in the postcondition?
*
* without this some proofs that use `assert e by t` fail
* the way `assert e by t` works is that, it is desugared into `with_tactic e t`
* that is abstract and remains in the VC as is at some point, we take a pass over
* the VC, find the `with_tactic e t` nodes in it, farm out `G |= e by t` where `G`
* is the context at that point in the VC in the original VC, `with_tactic e t`
* is simply replace by `True`.
* So why is it OK to replace it by `True`, don't we lose the fact that `e` holds for
* the rest of the VC?
* In the wp world of things, this works fine, since the wp of `assert e by t` is
* (fun _ -> with_tactic e t /\ (e ==> ...))
* i.e. the type of `assert e by t` already introduces a cut, so replacing it by
* `True` works fine.
*
* But this doesn't work when we use the intricate `~ (wp (fun r -> r =!= x))`
* combinator to convert from wp to pre post
*
* Basically, the shape of the VC in that case becomes:
* (with_tactic e t /\ (((~ with_tactic e t) \/ (e /\ ...)) ==> ...))
*
* In this VC, if we replace the first `with_tactic e t` with `True`, for the second conjunct,
* the solver can no longer reason that the first disjunct cannot hold
*
* The wp (fun _ -> True) below helps add that assumption to the second conjunct
*)
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_monotonicity wp;
fun s0 ->
let x = f () in
x, s0
sub_effect PURE ~> MSTATE = lift_pure_mst
(*
* A polymonadic bind between DIV and MSTATE
*
* This is ultimately used when defining par and frame in Steel.Effect.fst (via NMST layer)
* par and frame try to compose reified Steel with Steel, since Steel is non total, its reification
* incurs a Div effect, and so, we need a way to compose Div and Steel
*
* To do so, we have to go all the way down and have a story for MST and NMST too
*
* This polymonadic bind gives us bare minimum to realize that
* It is quite imprecise, in that it doesn't say anything about the post of the Div computation
* That's because, the as_ensures combinator is not encoded for Div effect in the SMT,
* the way it is done for PURE and GHOST
*
* However, since the reification use case gives us Dv anyway, this is fine for now
*)
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 s1 -> exists x. (ens x) s0 y s1)
= elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
(g x) s0
polymonadic_bind (DIV, MSTATE) |> MSTATE = bind_div_mst
let mst_assume (#state:Type u#2) (#rel:P.preorder state) (p:Type)
: MSTATE unit state rel (fun _ -> True) (fun m0 _ m1 -> p /\ m0 == m1)
=
assume p
let mst_admit (#state:Type u#2) (#rel:P.preorder state) (#a:Type) ()
: MSTATE a state rel (fun _ -> True) (fun _ _ _ -> False)
=
admit ()
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
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) | [
{
"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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f | 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 ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) = | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) | [] | 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_g ens_g) | {
"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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_monotonicity wp;
fun s0 ->
let x = f () in
x, s0 | 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 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)))) = | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [
"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",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (p ==> req_then s) /\ ((~ p) ==> req_else s))
(fun s0 x s1 -> (p ==> ens_then s0 x s1) /\ ((~ p) ==> ens_else s0 x s1))
[@@ primitive_extraction]
reflectable
effect {
MSTATE (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
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)
[@@ noextract_to "krml"]
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)
assume
val witness (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
: MSTATE (W.witnessed state rel p) state rel
(fun s0 -> p s0 /\ W.stable state rel p)
(fun s0 _ s1 -> s0 == s1)
assume
val recall (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
(w:W.witnessed state rel p)
: MSTATE unit state rel
(fun _ -> True)
(fun s0 _ s1 -> s0 == s1 /\ p s1)
(*
* AR: why do we need the first conjunct in the postcondition?
*
* without this some proofs that use `assert e by t` fail
* the way `assert e by t` works is that, it is desugared into `with_tactic e t`
* that is abstract and remains in the VC as is at some point, we take a pass over
* the VC, find the `with_tactic e t` nodes in it, farm out `G |= e by t` where `G`
* is the context at that point in the VC in the original VC, `with_tactic e t`
* is simply replace by `True`.
* So why is it OK to replace it by `True`, don't we lose the fact that `e` holds for
* the rest of the VC?
* In the wp world of things, this works fine, since the wp of `assert e by t` is
* (fun _ -> with_tactic e t /\ (e ==> ...))
* i.e. the type of `assert e by t` already introduces a cut, so replacing it by
* `True` works fine.
*
* But this doesn't work when we use the intricate `~ (wp (fun r -> r =!= x))`
* combinator to convert from wp to pre post
*
* Basically, the shape of the VC in that case becomes:
* (with_tactic e t /\ (((~ with_tactic e t) \/ (e /\ ...)) ==> ...))
*
* In this VC, if we replace the first `with_tactic e t` with `True`, for the second conjunct,
* the solver can no longer reason that the first disjunct cannot hold
*
* The wp (fun _ -> True) below helps add that assumption to the second conjunct
*)
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)))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (fun r -> ~(r == x) \/ ~(s0 == s1)))) | {
"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
(fun s0 -> wp (fun _ -> True) /\ (forall x. req x s0))
(fun s0 y s1 -> exists x. (ens x) s0 y 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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 s1 -> exists x. (ens x) s0 y s1)
= elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
(g x) s0 | 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
(fun s0 -> wp (fun _ -> True) /\ (forall x. req x s0))
(fun s0 y s1 -> exists x. (ens x) s0 y s1)
let 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
(fun s0 -> wp (fun _ -> True) /\ (forall x. req x s0))
(fun s0 y s1 -> exists x. (ens x) s0 y s1) = | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [
"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_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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (p ==> req_then s) /\ ((~ p) ==> req_else s))
(fun s0 x s1 -> (p ==> ens_then s0 x s1) /\ ((~ p) ==> ens_else s0 x s1))
[@@ primitive_extraction]
reflectable
effect {
MSTATE (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
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)
[@@ noextract_to "krml"]
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)
assume
val witness (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
: MSTATE (W.witnessed state rel p) state rel
(fun s0 -> p s0 /\ W.stable state rel p)
(fun s0 _ s1 -> s0 == s1)
assume
val recall (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
(w:W.witnessed state rel p)
: MSTATE unit state rel
(fun _ -> True)
(fun s0 _ s1 -> s0 == s1 /\ p s1)
(*
* AR: why do we need the first conjunct in the postcondition?
*
* without this some proofs that use `assert e by t` fail
* the way `assert e by t` works is that, it is desugared into `with_tactic e t`
* that is abstract and remains in the VC as is at some point, we take a pass over
* the VC, find the `with_tactic e t` nodes in it, farm out `G |= e by t` where `G`
* is the context at that point in the VC in the original VC, `with_tactic e t`
* is simply replace by `True`.
* So why is it OK to replace it by `True`, don't we lose the fact that `e` holds for
* the rest of the VC?
* In the wp world of things, this works fine, since the wp of `assert e by t` is
* (fun _ -> with_tactic e t /\ (e ==> ...))
* i.e. the type of `assert e by t` already introduces a cut, so replacing it by
* `True` works fine.
*
* But this doesn't work when we use the intricate `~ (wp (fun r -> r =!= x))`
* combinator to convert from wp to pre post
*
* Basically, the shape of the VC in that case becomes:
* (with_tactic e t /\ (((~ with_tactic e t) \/ (e /\ ...)) ==> ...))
*
* In this VC, if we replace the first `with_tactic e t` with `True`, for the second conjunct,
* the solver can no longer reason that the first disjunct cannot hold
*
* The wp (fun _ -> True) below helps add that assumption to the second conjunct
*)
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_monotonicity wp;
fun s0 ->
let x = f () in
x, s0
sub_effect PURE ~> MSTATE = lift_pure_mst
(*
* A polymonadic bind between DIV and MSTATE
*
* This is ultimately used when defining par and frame in Steel.Effect.fst (via NMST layer)
* par and frame try to compose reified Steel with Steel, since Steel is non total, its reification
* incurs a Div effect, and so, we need a way to compose Div and Steel
*
* To do so, we have to go all the way down and have a story for MST and NMST too
*
* This polymonadic bind gives us bare minimum to realize that
* It is quite imprecise, in that it doesn't say anything about the post of the Div computation
* That's because, the as_ensures combinator is not encoded for Div effect in the SMT,
* the way it is done for PURE and GHOST
*
* However, since the reification use case gives us Dv anyway, this is fine for now
*)
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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
(fun s0 -> wp (fun _ -> True) /\ (forall x. req x s0))
(fun s0 y s1 -> exists x. (ens x) s0 y s1) | [] | 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.repr b state rel (req x) (ens x))
-> FStar.MST.repr b
state
rel
(fun s0 -> wp (fun _ -> Prims.l_True) /\ (forall (x: a). req x s0))
(fun s0 y s1 -> exists (x: a). ens x s0 y s1) | {
"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
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) | [
{
"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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1 | 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
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
let 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
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) = | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) | [] | 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: a -> FStar.MST.repr b state rel (req_g x) (ens_g x))
-> FStar.MST.repr b
state
rel
(fun s0 -> req_f s0 /\ (forall (x: a) (s1: state). ens_f s0 x s1 ==> req_g x s1))
(fun s0 r s2 ->
req_f s0 /\ (exists (x: a) (s1: state). ens_f s0 x s1 /\ req_g x s1 /\ ens_g x s1 r s2)) | {
"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_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": false,
"source_file": "FStar.MST.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MST
module P = FStar.Preorder
module W = FStar.Witnessed.Core
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
DIV (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, 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)
=
fun s0 -> x, s0
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 state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
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_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (p ==> req_then s) /\ ((~ p) ==> req_else s))
(fun s0 x s1 -> (p ==> ens_then s0 x s1) /\ ((~ p) ==> ens_else s0 x s1))
[@@ primitive_extraction]
reflectable
effect {
MSTATE (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
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)
[@@ noextract_to "krml"]
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)
assume
val witness (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
: MSTATE (W.witnessed state rel p) state rel
(fun s0 -> p s0 /\ W.stable state rel p)
(fun s0 _ s1 -> s0 == s1)
assume
val recall (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
(w:W.witnessed state rel p)
: MSTATE unit state rel
(fun _ -> True)
(fun s0 _ s1 -> s0 == s1 /\ p s1)
(*
* AR: why do we need the first conjunct in the postcondition?
*
* without this some proofs that use `assert e by t` fail
* the way `assert e by t` works is that, it is desugared into `with_tactic e t`
* that is abstract and remains in the VC as is at some point, we take a pass over
* the VC, find the `with_tactic e t` nodes in it, farm out `G |= e by t` where `G`
* is the context at that point in the VC in the original VC, `with_tactic e t`
* is simply replace by `True`.
* So why is it OK to replace it by `True`, don't we lose the fact that `e` holds for
* the rest of the VC?
* In the wp world of things, this works fine, since the wp of `assert e by t` is
* (fun _ -> with_tactic e t /\ (e ==> ...))
* i.e. the type of `assert e by t` already introduces a cut, so replacing it by
* `True` works fine.
*
* But this doesn't work when we use the intricate `~ (wp (fun r -> r =!= x))`
* combinator to convert from wp to pre post
*
* Basically, the shape of the VC in that case becomes:
* (with_tactic e t /\ (((~ with_tactic e t) \/ (e /\ ...)) ==> ...))
*
* In this VC, if we replace the first `with_tactic e t` with `True`, for the second conjunct,
* the solver can no longer reason that the first disjunct cannot hold
*
* The wp (fun _ -> True) below helps add that assumption to the second conjunct
*)
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_monotonicity wp;
fun s0 ->
let x = f () in
x, s0
sub_effect PURE ~> MSTATE = lift_pure_mst
(*
* A polymonadic bind between DIV and MSTATE
*
* This is ultimately used when defining par and frame in Steel.Effect.fst (via NMST layer)
* par and frame try to compose reified Steel with Steel, since Steel is non total, its reification
* incurs a Div effect, and so, we need a way to compose Div and Steel
*
* To do so, we have to go all the way down and have a story for MST and NMST too
*
* This polymonadic bind gives us bare minimum to realize that
* It is quite imprecise, in that it doesn't say anything about the post of the Div computation
* That's because, the as_ensures combinator is not encoded for Div effect in the SMT,
* the way it is done for PURE and GHOST
*
* However, since the reification use case gives us Dv anyway, this is fine for now
*)
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 s1 -> exists x. (ens x) s0 y s1)
= elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
(g x) s0
polymonadic_bind (DIV, MSTATE) |> MSTATE = bind_div_mst
let mst_assume (#state:Type u#2) (#rel:P.preorder state) (p:Type)
: MSTATE unit state rel (fun _ -> True) (fun m0 _ m1 -> p /\ m0 == m1)
=
assume p
let mst_admit (#state:Type u#2) (#rel:P.preorder state) (#a:Type) ()
: MSTATE a state rel (fun _ -> True) (fun _ _ _ -> False)
=
admit ()
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": true,
"source_file": "Steel.Closure.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Closure
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.FractionalPermission
[@@__reduce__]
let repr (r:ref int) (x:int) = pts_to r full_perm (hide x) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": true,
"source_file": "Steel.Closure.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Closure
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.FractionalPermission | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": true,
"source_file": "Steel.Closure.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Closure
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.FractionalPermission
[@@__reduce__]
let repr (r:ref int) (x:int) = pts_to r full_perm (hide x)
let ctr (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)
= let v = read_pt r in
let (x:int { x == prev + 1 }) = v + 1 in
write_pt r x;
x
val new_counter' (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0)
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": true,
"source_file": "Steel.Closure.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Closure
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.FractionalPermission
[@@__reduce__]
let repr (r:ref int) (x:int) = pts_to r full_perm (hide x)
let ctr (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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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"
],
"interface_file": true,
"source_file": "Steel.Closure.fst"
} | [] | [
"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",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Closure.repr",
"Steel.Memory.mem",
"Prims.Mkdtuple2",
"Steel.Closure.ctr",
"Steel.Closure.next",
"Steel.Reference.ref",
"Steel.Reference.alloc_pt"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Closure
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.FractionalPermission
[@@__reduce__]
let repr (r:ref int) (x:int) = pts_to r full_perm (hide x)
let ctr (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)
= let v = read_pt r in
let (x:int { x == prev + 1 }) = v + 1 in
write_pt r x;
x
val new_counter' (u:unit) :
SteelT ctr_t emp (fun r -> dfst r 0) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
val lemma_ab_le_cd (a b c d:nat) : Lemma
(requires a <= c /\ b <= d)
(ensures a * b <= c * d) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_mul"
] | [] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (a % n) b n
val lemma_mod_sub_distr (a b:int) (n:pos) : Lemma ((a - b) % n = (a % n - b % n) % n) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
val lemma_mod_mul_distr (a b:int) (n:pos) : Lemma (a * b % n = (a % n) * (b % n) % n) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
val lemma_a_plus_b_pow2_mod2 (a b:int) (c:pos) : Lemma ((a + b * pow2 c) % 2 = a % 2) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.swap_mul mma mb;
Math.Lemmas.paren_mul_right mb mma mmb }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
} | 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) }
ma * (mb * (mma * mmb));
( == ) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
(ma * 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.MathLemmas.lemma_ab_le_cd",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.swap_mul"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.lemma_distr_pow",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.distributivity_add_left",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
val lemma_distr_pow (a b:int) (c d:nat) : Lemma ((a + b * pow2 c) * pow2 d = a * pow2 d + b * pow2 (c + d)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
}
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 + a3 * pow2 156 + a4 * pow2 208))
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 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + c * b4 * pow2 208 - a4 * pow2 208;
(==) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
}
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 =
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))
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 / pow2 b + c % pow2 d * pow2 e < pow2 (d + e)) | 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_right",
"Prims.int"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
}
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 + a3 * pow2 156 + a4 * pow2 208))
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 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + c * b4 * pow2 208 - a4 * pow2 208;
(==) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
}
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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;
(==) { Math.Lemmas.distributivity_add_left a2 (a3 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
} | 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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
( == ) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * 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.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.squash"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_definition a b }
r * a;
} | 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",
"FStar.Math.Lemmas.paren_mul_right",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Math.Lemmas.euclidean_division_definition"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_eucl_mul (r a:int) (b:pos) : Lemma (r * (a % b) + r * (a / b) * b = r * a) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 % pow2 b + (a / pow2 b) * pow2 b) * pow2 c + d * pow2 (f + g);
(==) { Math.Lemmas.euclidean_division_definition a (pow2 b) }
a * pow2 c + d * pow2 (f + g);
} | 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 + g);
( == ) { Math.Lemmas.euclidean_division_definition a (pow2 b) }
a * pow2 c + d * pow2 (f + g);
} | {
"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.Calc.calc_pack",
"Hacl.Spec.K256.MathLemmas.lemma_distr_pow",
"Prims.squash",
"FStar.Math.Lemmas.euclidean_division_definition"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
}
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 + a3 * pow2 156 + a4 * pow2 208))
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 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + c * b4 * pow2 208 - a4 * pow2 208;
(==) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
}
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 =
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))
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 =
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_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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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;
(==) { Math.Lemmas.paren_mul_right (a / pow2 52) (pow2 52) (pow2 b); Math.Lemmas.pow2_plus 52 b }
a * pow2 b - a / pow2 52 * pow2 (52 + 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_right (a / pow2 52) (pow2 52) (pow2 b);
Math.Lemmas.pow2_plus 52 b) }
a * pow2 b - (a / pow2 52) * pow2 (52 + 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.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.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
}
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 + a3 * pow2 156 + a4 * pow2 208))
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 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + c * b4 * pow2 208 - a4 * pow2 208;
(==) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
}
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 =
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))
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 =
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_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 =
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 + g);
(==) { Math.Lemmas.euclidean_division_definition a (pow2 b) }
a * pow2 c + d * pow2 (f + g);
}
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.distributivity_add_right r (a / b * b) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
} | 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) (c * b) }
r * (a % b) + r * ((a / b) * b) + r * (c * b);
( == ) { (Math.Lemmas.paren_mul_right r (a / b) b;
Math.Lemmas.paren_mul_right r c b) }
r * (a % b) + (r * (a / b)) * b + (r * c) * b;
( == ) { lemma_distr_eucl_mul r a b }
r * a + (r * 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",
"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",
"FStar.Math.Lemmas.paren_mul_right",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.distributivity_add_right",
"Hacl.Spec.K256.MathLemmas.lemma_distr_eucl_mul"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 + r3) 52 104 }
(r4 * pow2 52 + r3) * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
} | 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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
( == ) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
} | {
"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",
"Prims.squash"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 + (r1 + (r2 + pow2 64 * r3) * pow2 64) * pow2 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
} | 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 64;
( == ) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
( == ) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
( == ) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
} | {
"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.squash",
"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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
} | 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 b1 b2 b3 b4 p = | 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 * b4) * pow2 208) *
pow2 p;
( == ) { lemma_distr_pow (a * b0 + (a * b1) * pow2 52 + (a * b2) * pow2 104 + (a * b3) * pow2 156)
(a * b4)
208
p }
(a * b0 + (a * b1) * pow2 52 + (a * b2) * pow2 104 + (a * b3) * pow2 156) * pow2 p +
(a * b4) * pow2 (208 + p);
( == ) { lemma_distr_pow (a * b0 + (a * b1) * pow2 52 + (a * b2) * pow2 104) (a * b3) 156 p }
(a * b0 + (a * b1) * pow2 52 + (a * b2) * pow2 104) * pow2 p + (a * b3) * pow2 (156 + p) +
(a * b4) * pow2 (208 + p);
( == ) { lemma_distr_pow (a * b0 + (a * b1) * pow2 52) (a * b2) 104 p }
(a * b0 + (a * b1) * pow2 52) * pow2 p + (a * b2) * pow2 (104 + p) + (a * b3) * pow2 (156 + p) +
(a * b4) * pow2 (208 + p);
( == ) { lemma_distr_pow (a * b0) (a * b1) 52 p }
(a * b0) * pow2 p + (a * b1) * pow2 (52 + p) + (a * b2) * pow2 (104 + p) +
(a * b3) * pow2 (156 + p) +
(a * b4) * pow2 (208 + p);
} | {
"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.lemma_swap_mul3",
"Prims.squash",
"Hacl.Spec.K256.MathLemmas.lemma_distr5_pow52",
"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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 * b0) * Prims.pow2 p + (a * b1) * Prims.pow2 (52 + p) + (a * b2) * Prims.pow2 (104 + p) +
(a * b3) * Prims.pow2 (156 + p) +
(a * b4) * Prims.pow2 (208 + p)) | {
"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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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;
(==) { lemma_swap_mul3 b1 (pow2 52) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
} | 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) a;
lemma_swap_mul3 b2 (pow2 104) a) }
b0 * a + (b1 * a) * pow2 52 + (b2 * a) * pow2 104 + (b3 * pow2 156) * a + (b4 * pow2 208) * a;
( == ) { (lemma_swap_mul3 b3 (pow2 156) a;
lemma_swap_mul3 b4 (pow2 208) a) }
b0 * a + (b1 * a) * pow2 52 + (b2 * a) * pow2 104 + (b3 * a) * pow2 156 + (b4 * a) * pow2 208;
} | {
"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",
"Prims.squash",
"Hacl.Spec.K256.MathLemmas.lemma_swap_mul3"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 + (a * b3) * Prims.pow2 156 +
(a * b4) * Prims.pow2 208) | {
"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 + a3 * pow2 156 + a4 * 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + c * b4 * pow2 208 - a4 * pow2 208;
(==) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
} | 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 + a3 * pow2 156 + a4 * pow2 208))
let lemma_distr5_pow52_sub a0 a1 a2 a3 a4 b0 b1 b2 b3 b4 c = | 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 +
(b4 * c - a4) * pow2 208;
( == ) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + (c * b1) * pow2 52 - a1 * pow2 52 + (c * b2) * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 +
(b4 * c - a4) * pow2 208;
( == ) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + (c * b1) * pow2 52 - a1 * pow2 52 + (c * b2) * pow2 104 - a2 * pow2 104 +
(c * b3) * pow2 156 -
a3 * pow2 156 +
(b4 * c - a4) * pow2 208;
( == ) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + (c * b1) * pow2 52 - a1 * pow2 52 + (c * b2) * pow2 104 - a2 * pow2 104 +
(c * b3) * pow2 156 -
a3 * pow2 156 +
(c * b4) * pow2 208 -
a4 * pow2 208;
( == ) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
} | {
"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.Lemmas.distributivity_sub_left",
"Prims.squash",
"Hacl.Spec.K256.MathLemmas.lemma_distr5_pow52"
] | [] | 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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
}
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 + a3 * pow2 156 + a4 * pow2 208)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 + a3 * pow2 156 + a4 * pow2 208)) | [] | 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 + (b2 * c - a2) * Prims.pow2 104 +
(b3 * c - a3) * Prims.pow2 156 +
(b4 * c - a4) * Prims.pow2 208 ==
(b0 + b1 * Prims.pow2 52 + b2 * Prims.pow2 104 + b3 * Prims.pow2 156 + b4 * Prims.pow2 208) *
c -
(a0 + a1 * Prims.pow2 52 + a2 * Prims.pow2 104 + a3 * Prims.pow2 156 + a4 * Prims.pow2 208)) | {
"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 * pow2 104 + t3 * pow2 156 + t4 * 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_mod_52_mul_b a 52 }
t0 % pow2 52 + (t1 + t0 / pow2 52) * pow2 52 - a / pow2 52 * pow2 104 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 + d * pow2 208;
(==) { lemma_distr_eucl t0 t1 }
t0 + t1 * pow2 52 - a / pow2 52 * pow2 104 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 + d * pow2 208;
(==) { lemma_a_mod_52_mul_b b 104 }
t0 + t1 * pow2 52 - a / pow2 52 * pow2 104 + (t2 + a / pow2 52) * pow2 104 - b / pow2 52 * pow2 156 +
(c % pow2 52) * pow2 156 + d * pow2 208;
(==) { Math.Lemmas.distributivity_add_left t2 (a / pow2 52) (pow2 104) }
t0 + t1 * pow2 52 + t2 * pow2 104 - b / pow2 52 * pow2 156 +
(c % pow2 52) * pow2 156 + d * pow2 208;
(==) { lemma_a_mod_52_mul_b c 156 }
t0 + t1 * pow2 52 + t2 * pow2 104 - b / pow2 52 * pow2 156 +
(t3 + b / pow2 52) * pow2 156 - c / pow2 52 * pow2 208 + d * pow2 208;
(==) { Math.Lemmas.distributivity_add_left t3 (b / pow2 52) (pow2 156) }
t0 + t1 * pow2 52 + t2 * pow2 104 + t3 * pow2 156 - c / pow2 52 * pow2 208 + (t4 + c / pow2 52) * pow2 208;
(==) { Math.Lemmas.distributivity_add_left t4 (c / pow2 52) (pow2 208) }
t0 + t1 * pow2 52 + t2 * pow2 104 + t3 * pow2 156 + t4 * pow2 208;
} | 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 * pow2 104 + t3 * pow2 156 + t4 * pow2 208)
let lemma_simplify_carry_round t0 t1 t2 t3 t4 = | 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) * pow2 52 - (a / pow2 52) * pow2 104 + (b % pow2 52) * pow2 104 +
(c % pow2 52) * pow2 156 +
d * pow2 208;
( == ) { lemma_distr_eucl t0 t1 }
t0 + t1 * pow2 52 - (a / pow2 52) * pow2 104 + (b % pow2 52) * pow2 104 + (c % pow2 52) * pow2 156 +
d * pow2 208;
( == ) { lemma_a_mod_52_mul_b b 104 }
t0 + t1 * pow2 52 - (a / pow2 52) * pow2 104 + (t2 + a / pow2 52) * pow2 104 -
(b / pow2 52) * pow2 156 +
(c % pow2 52) * pow2 156 +
d * pow2 208;
( == ) { Math.Lemmas.distributivity_add_left t2 (a / pow2 52) (pow2 104) }
t0 + t1 * pow2 52 + t2 * pow2 104 - (b / pow2 52) * pow2 156 + (c % pow2 52) * pow2 156 +
d * pow2 208;
( == ) { lemma_a_mod_52_mul_b c 156 }
t0 + t1 * pow2 52 + t2 * pow2 104 - (b / pow2 52) * pow2 156 + (t3 + b / pow2 52) * pow2 156 -
(c / pow2 52) * pow2 208 +
d * pow2 208;
( == ) { Math.Lemmas.distributivity_add_left t3 (b / pow2 52) (pow2 156) }
t0 + t1 * pow2 52 + t2 * pow2 104 + t3 * pow2 156 - (c / pow2 52) * pow2 208 +
(t4 + c / pow2 52) * pow2 208;
( == ) { Math.Lemmas.distributivity_add_left t4 (c / pow2 52) (pow2 208) }
t0 + t1 * pow2 52 + t2 * pow2 104 + t3 * pow2 156 + t4 * pow2 208;
} | {
"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.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.K256.MathLemmas.lemma_a_mod_52_mul_b",
"Prims.squash",
"Hacl.Spec.K256.MathLemmas.lemma_distr_eucl",
"FStar.Math.Lemmas.distributivity_add_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 }
a * (c * b);
(==) { Math.Lemmas.paren_mul_right a c b }
a * c * b;
}
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 =
Math.Lemmas.lemma_mod_mul_distr_l a b n;
Math.Lemmas.lemma_mod_mul_distr_r (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 =
Math.Lemmas.lemma_mod_plus_distr_l a (- b) n;
Math.Lemmas.lemma_mod_sub_distr (a % n) b n
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 =
Math.Lemmas.lemma_mult_le_left a b d;
Math.Lemmas.lemma_mult_le_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 =
Math.Lemmas.lemma_mult_lt_left a b d;
Math.Lemmas.lemma_mult_lt_right d a c
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 =
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 }
ma * (mb * (mma * mmb));
(==) { Math.Lemmas.paren_mul_right ma mb (mma * mmb) }
ma * mb * (mma * mmb);
}
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 =
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_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 =
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_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 =
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;
}
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 =
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) (c * b) }
r * (a % b) + r * (a / b * b) + r * (c * b);
(==) { Math.Lemmas.paren_mul_right r (a / b) b; Math.Lemmas.paren_mul_right r c b }
r * (a % b) + r * (a / b) * b + r * c * b;
(==) { lemma_distr_eucl_mul r a b }
r * a + r * c * b;
}
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 = lemma_distr_eucl_mul_add 1 a b (pow2 52)
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 =
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_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 =
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 64;
(==) { lemma_distr_pow r1 (r2 + pow2 64 * r3) 64 64 }
r0 + r1 * pow2 64 + (r2 + pow2 64 * r3) * pow2 128;
(==) { Math.Lemmas.swap_mul (pow2 64) r3 }
r0 + r1 * pow2 64 + (r2 + r3 * pow2 64) * pow2 128;
(==) { lemma_distr_pow r2 r3 64 128 }
r0 + r1 * pow2 64 + r2 * pow2 128 + r3 * pow2 192;
}
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 =
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 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
(==) { lemma_distr_pow r3 r4 52 156 }
r4 * pow2 208 + r3 * pow2 156 + r2 * pow2 104 + r1 * pow2 52 + r0;
}
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 =
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 + a4) b }
a0 * b + a1 * b + a2 * b + (a3 + a4) * b;
(==) { Math.Lemmas.distributivity_add_left a3 a4 b }
a0 * b + a1 * b + a2 * b + a3 * b + a4 * b;
}
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 =
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) a; lemma_swap_mul3 b2 (pow2 104) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * pow2 156 * a + b4 * pow2 208 * a;
(==) { lemma_swap_mul3 b3 (pow2 156) a; lemma_swap_mul3 b4 (pow2 208) a }
b0 * a + b1 * a * pow2 52 + b2 * a * pow2 104 + b3 * a * pow2 156 + b4 * a * pow2 208;
}
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 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 52 + a * b2 * pow2 104 + a * b3 * pow2 156 + a * b4 * pow2 208) * pow2 p;
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) (a * b4) 208 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104 + a * b3 * pow2 156) * pow2 p + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) (a * b3) 156 p }
(a * b0 + a * b1 * pow2 52 + a * b2 * pow2 104) * pow2 p + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0 + a * b1 * pow2 52) (a * b2) 104 p }
(a * b0 + a * b1 * pow2 52) * pow2 p + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
(==) { lemma_distr_pow (a * b0) (a * b1) 52 p }
a * b0 * pow2 p + a * b1 * pow2 (52 + p) + a * b2 * pow2 (104 + p) + a * b3 * pow2 (156 + p) + a * b4 * pow2 (208 + p);
}
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 + a3 * pow2 156 + a4 * pow2 208))
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 * pow2 52 + (b2 * c - a2) * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b2 * c) a2 (pow2 104) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
(b3 * c - a3) * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b3 * c) a3 (pow2 156) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + (b4 * c - a4) * pow2 208;
(==) { Math.Lemmas.distributivity_sub_left (b4 * c) a4 (pow2 208) }
c * b0 - a0 + c * b1 * pow2 52 - a1 * pow2 52 + c * b2 * pow2 104 - a2 * pow2 104 +
c * b3 * pow2 156 - a3 * pow2 156 + c * b4 * pow2 208 - a4 * pow2 208;
(==) { lemma_distr5_pow52 c b0 b1 b2 b3 b4 }
(b0 + b1 * pow2 52 + b2 * pow2 104 + b3 * pow2 156 + b4 * pow2 208) * c -
(a0 + a1 * pow2 52 + a2 * pow2 104 + a3 * pow2 156 + a4 * pow2 208);
}
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 =
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))
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 =
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_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 =
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 + g);
(==) { Math.Lemmas.euclidean_division_definition a (pow2 b) }
a * pow2 c + d * pow2 (f + g);
}
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 =
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_right (a / pow2 52) (pow2 52) (pow2 b); Math.Lemmas.pow2_plus 52 b }
a * pow2 b - a / pow2 52 * pow2 (52 + b);
}
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 * pow2 104 + t3 * pow2 156 + t4 * pow2 208) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 * pow2 104 + t3 * pow2 156 + t4 * pow2 208) | [] | 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 + (a % Prims.pow2 52) * Prims.pow2 52 +
(b % Prims.pow2 52) * Prims.pow2 104 +
(c % Prims.pow2 52) * Prims.pow2 156 +
d * Prims.pow2 208 ==
t0 + t1 * Prims.pow2 52 + t2 * Prims.pow2 104 + t3 * Prims.pow2 156 + t4 * Prims.pow2 208)) | {
"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"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum25519.fsti"
} | [
"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"
(* Type abbreviations *)
inline_for_extraction noextract
let felem = lbuffer uint64 5ul
(* A point is buffer of size 20, that is 4 consecutive buffers of size 5 *) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum25519.fsti"
} | [
"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"
(* Type abbreviations *) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum25519.fsti"
} | [] | [
"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"
(* Type abbreviations *)
inline_for_extraction noextract
let felem = lbuffer uint64 5ul
(* A point is buffer of size 20, that is 4 consecutive buffers of size 5 *)
inline_for_extraction noextract
let point = lbuffer uint64 20ul
inline_for_extraction noextract
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
inline_for_extraction noextract
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
inline_for_extraction noextract
let getz (p:point) : Stack felem
(requires fun h -> live h p) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum25519.fsti"
} | [] | [
"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"
(* Type abbreviations *)
inline_for_extraction noextract
let felem = lbuffer uint64 5ul
(* A point is buffer of size 20, that is 4 consecutive buffers of size 5 *)
inline_for_extraction noextract
let point = lbuffer uint64 20ul
inline_for_extraction noextract
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
inline_for_extraction noextract
let gety (p:point) : Stack felem
(requires fun h -> live h p) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum25519.fsti"
} | [] | [
"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"
(* Type abbreviations *)
inline_for_extraction noextract
let felem = lbuffer uint64 5ul
(* A point is buffer of size 20, that is 4 consecutive buffers of size 5 *)
inline_for_extraction noextract
let point = lbuffer uint64 20ul
inline_for_extraction noextract
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
inline_for_extraction noextract
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
inline_for_extraction noextract
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
inline_for_extraction noextract
let gett (p:point) : Stack felem
(requires fun h -> live h p) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum25519.fsti"
} | [] | [
"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"
(* Type abbreviations *)
inline_for_extraction noextract
let felem = lbuffer uint64 5ul
(* A point is buffer of size 20, that is 4 consecutive buffers of size 5 *)
inline_for_extraction noextract
let point = lbuffer uint64 20ul
inline_for_extraction noextract
let getx (p:point) : Stack felem
(requires fun h -> live h p) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_common_s.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 Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
// substitution is endian-neutral;
assume val sub_bytes (q:quad32) : quad32
assume val inv_sub_bytes (q:quad32) : quad32
assume val sub_word (w:nat32) : nat32
type algorithm:eqtype = | AES_128 | AES_192 | AES_256
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 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_common_s.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 Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
// substitution is endian-neutral;
assume val sub_bytes (q:quad32) : quad32
assume val inv_sub_bytes (q:quad32) : quad32
assume val sub_word (w:nat32) : nat32
type algorithm:eqtype = | AES_128 | AES_192 | AES_256
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
// AES fixes Rijndael's block size at 4 32-bit words
let nb = 4
// Number of key words
unfold let nk(alg:algorithm) =
match alg with
| AES_128 -> 4
| AES_192 -> 6
| AES_256 -> 8
// Number of rounds
unfold let nr(alg:algorithm) =
match alg with
| AES_128 -> 10
| AES_192 -> 12
| AES_256 -> 14 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_common_s.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 Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
// substitution is endian-neutral;
assume val sub_bytes (q:quad32) : quad32
assume val inv_sub_bytes (q:quad32) : quad32
assume val sub_word (w:nat32) : nat32
type algorithm:eqtype = | AES_128 | AES_192 | AES_256 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_common_s.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 Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
// substitution is endian-neutral;
assume val sub_bytes (q:quad32) : quad32
assume val inv_sub_bytes (q:quad32) : quad32
assume val sub_word (w:nat32) : nat32
type algorithm:eqtype = | AES_128 | AES_192 | AES_256
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
// AES fixes Rijndael's block size at 4 32-bit words
let nb = 4
// Number of key words
unfold let nk(alg:algorithm) =
match alg with
| AES_128 -> 4
| AES_192 -> 6
| AES_256 -> 8
// Number of rounds | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_common_s.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 Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
// substitution is endian-neutral;
assume val sub_bytes (q:quad32) : quad32
assume val inv_sub_bytes (q:quad32) : quad32
assume val sub_word (w:nat32) : nat32
type algorithm:eqtype = | AES_128 | AES_192 | AES_256
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
// AES fixes Rijndael's block size at 4 32-bit words
let nb = 4
// Number of key words | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Spec.Agile.HKDF",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 /\
B.length prk == hash_length a /\
v saltlen == B.length salt /\
v ikmlen == B.length ikm /\
Spec.Agile.HMAC.keysized a (v saltlen) /\
B.length ikm + block_length a < pow2 32)
(ensures fun h0 _ h1 ->
key_and_data_fits a;
B.modifies (B.loc_buffer prk) h0 h1 /\
B.as_seq h1 prk == extract a (B.as_seq h0 salt) (B.as_seq h0 ikm)) | 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_length a /\ v saltlen == B.length salt /\
v ikmlen == B.length ikm /\ Spec.Agile.HMAC.keysized a (v saltlen) /\
B.length ikm + block_length a < pow2 32)
(ensures
fun h0 _ h1 ->
key_and_data_fits a;
B.modifies (B.loc_buffer prk) h0 h1 /\
B.as_seq h1 prk == extract a (B.as_seq h0 salt) (B.as_seq h0 ikm)) | {
"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",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"EverCrypt.HMAC.fsti.checked"
],
"interface_file": false,
"source_file": "EverCrypt.HKDF.fsti"
} | [
"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",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Spec.Hash.Definitions.hash_length",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Spec.Agile.HMAC.keysized",
"Prims.op_LessThan",
"Prims.op_Addition",
"Spec.Hash.Definitions.block_length",
"Prims.pow2",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.as_seq",
"Spec.Agile.HKDF.extract",
"EverCrypt.HKDF.key_and_data_fits"
] | [] | (** 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_than_max_input_length` a)
=
let open FStar.Mul in
assert_norm (8 * 16 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125)
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)
/// Types for expand and extract
/// Duplicated from Hacl.HKDF because we don't want clients to depend on Hacl.HKDF
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Spec.Agile.HKDF",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"EverCrypt.HMAC.fsti.checked"
],
"interface_file": false,
"source_file": "EverCrypt.HKDF.fsti"
} | [
"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",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (** 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_than_max_input_length` a) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Spec.Agile.HKDF",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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?.v (max_input_length a)) = | 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",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"EverCrypt.HMAC.fsti.checked"
],
"interface_file": false,
"source_file": "EverCrypt.HKDF.fsti"
} | [
"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",
"Spec.Hash.Definitions.block_length",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.pos",
"Spec.Hash.Definitions.max_input_length",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (** 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_than_max_input_length` a)
=
let open FStar.Mul in
assert_norm (8 * 16 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125)
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Hash.Definitions.max_input_length a))
<:
Type0)) | {
"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,
"full_module": "Spec.Agile.HKDF",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 /\
v prklen == B.length prk /\
v infolen == B.length info /\
v len == B.length okm /\
hash_length a <= v prklen /\
Spec.Agile.HMAC.keysized a (v prklen) /\
hash_length a + v infolen + 1 + block_length a < pow2 32 /\
v len <= FStar.Mul.(255 * hash_length a))
(ensures fun h0 _ h1 ->
hash_block_length_fits a;
B.modifies (B.loc_buffer okm) h0 h1 /\
B.as_seq h1 okm == expand a (B.as_seq h0 prk) (B.as_seq h0 info) (v len)) | 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 prk /\ v infolen == B.length info /\ v len == B.length okm /\
hash_length a <= v prklen /\ Spec.Agile.HMAC.keysized a (v prklen) /\
hash_length a + v infolen + 1 + block_length a < pow2 32 /\
v len <= FStar.Mul.(255 * hash_length a))
(ensures
fun h0 _ h1 ->
hash_block_length_fits a;
B.modifies (B.loc_buffer okm) h0 h1 /\
B.as_seq h1 okm == expand a (B.as_seq h0 prk) (B.as_seq h0 info) (v len)) | {
"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",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"EverCrypt.HMAC.fsti.checked"
],
"interface_file": false,
"source_file": "EverCrypt.HKDF.fsti"
} | [
"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",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"LowStar.Monotonic.Buffer.length",
"Prims.op_LessThanOrEqual",
"Spec.Hash.Definitions.hash_length",
"Spec.Agile.HMAC.keysized",
"Prims.op_LessThan",
"Prims.op_Addition",
"Spec.Hash.Definitions.block_length",
"Prims.pow2",
"FStar.Mul.op_Star",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.as_seq",
"Spec.Agile.HKDF.expand",
"EverCrypt.HKDF.hash_block_length_fits"
] | [] | (** 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_than_max_input_length` a)
=
let open FStar.Mul in
assert_norm (8 * 16 + pow2 32 < pow2 61);
assert_norm (pow2 61 < pow2 125)
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)
/// Types for expand and extract
/// Duplicated from Hacl.HKDF because we don't want clients to depend on Hacl.HKDF
inline_for_extraction noextract
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 /\
B.length prk == hash_length a /\
v saltlen == B.length salt /\
v ikmlen == B.length ikm /\
Spec.Agile.HMAC.keysized a (v saltlen) /\
B.length ikm + block_length a < pow2 32)
(ensures fun h0 _ h1 ->
key_and_data_fits a;
B.modifies (B.loc_buffer prk) h0 h1 /\
B.as_seq h1 prk == extract a (B.as_seq h0 salt) (B.as_seq h0 ikm))
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 simpler variant with a non-dependent accumuator used to be called [repeat_range]
*)
val repeat_left:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo))
val repeat_left_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi)
(**
* fold_right-like loop combinator:
* [ repeat_right lo hi a f acc == f (hi - 1) .. ... (f (lo + 1) (f lo acc)) ]
*
* e.g. [ repeat_right 0 3 (fun _ -> list int) Cons [] == [2;1;0] ]
*
* It satisfies
* [ repeat_right lo hi (fun _ -> a) f acc == fold_right f acc [hi-1..lo] ]
*)
val repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo))
val repeat_right_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi) (decreases (hi - lo))
(** Splitting a repetition *)
val repeat_right_plus:
lo:nat
-> mi:nat{lo <= mi}
-> hi:nat{mi <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures
repeat_right lo hi a f acc ==
repeat_right mi hi a f (repeat_right lo mi a f acc))
(decreases hi)
(** Unfolding one iteration *)
val unfold_repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc0:a lo
-> i:nat{lo <= i /\ i < hi}
-> Lemma (
repeat_right lo (i + 1) a f acc0 ==
f i (repeat_right lo i a f acc0))
val eq_repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc0:a lo
-> Lemma (repeat_right lo lo a f acc0 == acc0)
(**
* [repeat_left] and [repeat_right] are equivalent.
*
* This follows from the third duality theorem
* [ fold_right f acc xs = fold_left (flip f) acc (reverse xs) ]
*)
val repeat_left_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures repeat_right lo hi a f acc == repeat_left lo hi a f acc)
(decreases (hi - lo))
(**
* Repetition starting from 0
*
* Defined as [repeat_right] for convenience, but [repeat_left] may be more
* efficient when extracted to OCaml.
*)
val repeat_gen:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> a n
val repeat_gen_all_ml:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> FStar.All.ML (a (i + 1)))
-> acc0:a 0
-> FStar.All.ML (a n)
(** Unfolding one iteration *)
val unfold_repeat_gen:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> i:nat{i < n}
-> Lemma (repeat_gen (i + 1) a f acc0 == f i (repeat_gen i a f acc0))
val eq_repeat_gen0:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> Lemma (repeat_gen 0 a f acc0 == acc0)
val repeat_gen_def:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> Lemma (repeat_gen n a f acc0 == repeat_right 0 n a f acc0)
(**
* Repetition with a fixed accumulator type
*)
let fixed_a (a:Type) (i:nat) = a | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 simpler variant with a non-dependent accumuator used to be called [repeat_range]
*)
val repeat_left:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo))
val repeat_left_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi)
(**
* fold_right-like loop combinator:
* [ repeat_right lo hi a f acc == f (hi - 1) .. ... (f (lo + 1) (f lo acc)) ]
*
* e.g. [ repeat_right 0 3 (fun _ -> list int) Cons [] == [2;1;0] ]
*
* It satisfies
* [ repeat_right lo hi (fun _ -> a) f acc == fold_right f acc [hi-1..lo] ]
*)
val repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo))
val repeat_right_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi) (decreases (hi - lo))
(** Splitting a repetition *)
val repeat_right_plus:
lo:nat
-> mi:nat{lo <= mi}
-> hi:nat{mi <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures
repeat_right lo hi a f acc ==
repeat_right mi hi a f (repeat_right lo mi a f acc))
(decreases hi)
(** Unfolding one iteration *)
val unfold_repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc0:a lo
-> i:nat{lo <= i /\ i < hi}
-> Lemma (
repeat_right lo (i + 1) a f acc0 ==
f i (repeat_right lo i a f acc0))
val eq_repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc0:a lo
-> Lemma (repeat_right lo lo a f acc0 == acc0)
(**
* [repeat_left] and [repeat_right] are equivalent.
*
* This follows from the third duality theorem
* [ fold_right f acc xs = fold_left (flip f) acc (reverse xs) ]
*)
val repeat_left_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures repeat_right lo hi a f acc == repeat_left lo hi a f acc)
(decreases (hi - lo))
(**
* Repetition starting from 0
*
* Defined as [repeat_right] for convenience, but [repeat_left] may be more
* efficient when extracted to OCaml.
*)
val repeat_gen:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> a n
val repeat_gen_all_ml:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> FStar.All.ML (a (i + 1)))
-> acc0:a 0
-> FStar.All.ML (a n)
(** Unfolding one iteration *)
val unfold_repeat_gen:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> i:nat{i < n}
-> Lemma (repeat_gen (i + 1) a f acc0 == f i (repeat_gen i a f acc0))
val eq_repeat_gen0:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> Lemma (repeat_gen 0 a f acc0 == acc0)
val repeat_gen_def:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> Lemma (repeat_gen n a f acc0 == repeat_right 0 n a f acc0)
(**
* Repetition with a fixed accumulator type
*) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.HyperStack.ST.fsti.checked",
"C.String.fsti.checked"
],
"interface_file": false,
"source_file": "EverCrypt.Helpers.fsti"
} | [
"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
/// follows.
effect Stack_ (a: Type) = Stack a (fun _ -> True) (fun _ _ _ -> True)
inline_for_extraction noextract
let uint8_t = UInt8.t
inline_for_extraction noextract
let uint16_t = UInt16.t
inline_for_extraction noextract
let uint32_t = UInt32.t | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.