file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
GTWP.fst | GTWP.wp | val wp : a: Type -> Type | let wp (a:Type) = pure_wp a | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 17,
"start_col": 0,
"start_line": 17
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_wp"
] | [] | false | false | false | true | true | let wp (a: Type) =
| pure_wp a | false | |
Lib.ByteSequence.fst | Lib.ByteSequence.nat_from_intseq_le_public_to_secret | val nat_from_intseq_le_public_to_secret:
#t:inttype{unsigned t} -> len:size_pos{len * bits t < pow2 32} -> b:lseq (uint_t t PUB) len ->
Lemma (nat_from_intseq_le b == nat_from_intseq_le (map secret b)) | val nat_from_intseq_le_public_to_secret:
#t:inttype{unsigned t} -> len:size_pos{len * bits t < pow2 32} -> b:lseq (uint_t t PUB) len ->
Lemma (nat_from_intseq_le b == nat_from_intseq_le (map secret b)) | let rec nat_from_intseq_le_public_to_secret #t len b =
if len = 1 then begin
nat_from_intseq_le_lemma0 b;
nat_from_intseq_le_lemma0 (map secret b) end
else begin
let b_secret = map secret b in
let b1 = slice b 1 len in
let b1_secret = slice b_secret 1 len in
nat_from_intseq_le_public_to_secr... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 836,
"start_col": 0,
"start_line": 820
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Lib.IntTypes.size_pos{len * Lib.IntTypes.bits t < Prims.pow2 32} ->
b: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.PUB) len
-> FStar.Pervasives.Lemma
(ensures
Lib.ByteSequence.nat_from_intseq_le b ==
Lib.ByteSequence.nat_from_intseq_le (Lib.Sequence.map Lib.IntTypes.secret b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Lib.IntTypes.size_pos",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Prims.pow2",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.PUB",
"Prims.op_Equality",
"Prims.int",
"Lib.ByteSequence.nat_from_i... | [
"recursion"
] | false | false | true | false | false | let rec nat_from_intseq_le_public_to_secret #t len b =
| if len = 1
then
(nat_from_intseq_le_lemma0 b;
nat_from_intseq_le_lemma0 (map secret b))
else
let b_secret = map secret b in
let b1 = slice b 1 len in
let b1_secret = slice b_secret 1 len in
nat_from_intseq_le_public_to_secret #t (len - 1) b1;
nat_from_intseq_le_slice_lemma b 1;
nat_from_intseq_le_lemm... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.mul_def | val mul_def (a b: poly)
: Pure poly
(requires True)
(ensures
fun p ->
let len = poly_length a + poly_length b in
poly_length p <= len /\
(forall (i: nat). {:pattern p.[ i ]} i < len ==> p.[ i ] == mul_element a b i)) | val mul_def (a b: poly)
: Pure poly
(requires True)
(ensures
fun p ->
let len = poly_length a + poly_length b in
poly_length p <= len /\
(forall (i: nat). {:pattern p.[ i ]} i < len ==> p.[ i ] == mul_element a b i)) | let mul_def (a b:poly) : Pure poly
(requires True)
(ensures fun p ->
let len = poly_length a + poly_length b in
poly_length p <= len /\
(forall (i:nat).{:pattern p.[i]} i < len ==> p.[i] == mul_element a b i)
)
=
let len = poly_length a + poly_length b in
of_fun len (fun (i:nat) -> mul_element a... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 182,
"start_col": 0,
"start_line": 173
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> Prims.Pure Vale.Math.Poly2_s.poly | Prims.Pure | [] | [] | [
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2_s.of_fun",
"Prims.nat",
"Vale.Math.Poly2.Galois.mul_element",
"Prims.bool",
"Prims.int",
"Prims.op_Addition",
"Vale.Math.Poly2.Galois.poly_length",
"Prims.l_True",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_Forall",
"Prims.l_... | [] | false | false | false | false | false | let mul_def (a b: poly)
: Pure poly
(requires True)
(ensures
fun p ->
let len = poly_length a + poly_length b in
poly_length p <= len /\
(forall (i: nat). {:pattern p.[ i ]} i < len ==> p.[ i ] == mul_element a b i)) =
| let len = poly_length a + poly_length b in
of_fun len (fun (i: nat) -> mul_element a b i) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_shift_right | val lemma_shift_right (f:G.field) (e:G.felem f) (n:I.shiftval f.G.t) : Lemma
(requires True)
(ensures to_poly (I.shift_right e n) == shift (to_poly e) (-(I.uint_v n)))
[SMTPat (to_poly (I.shift_right e n))] | val lemma_shift_right (f:G.field) (e:G.felem f) (n:I.shiftval f.G.t) : Lemma
(requires True)
(ensures to_poly (I.shift_right e n) == shift (to_poly e) (-(I.uint_v n)))
[SMTPat (to_poly (I.shift_right e n))] | let lemma_shift_right f e n =
let G.GF t irred = f in
let nf = I.bits t in
PL.lemma_index_all ();
PL.lemma_reverse_define_all ();
PL.lemma_shift_define_all ();
assert (I.uint_v (I.shift_right e n) == U.shift_right #nf (I.uint_v e) (I.uint_v n));
lemma_equal (to_poly (I.shift_right e n)) (shift (to_poly e)... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 146,
"start_col": 0,
"start_line": 139
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> e: Spec.GaloisField.felem f -> n: Lib.IntTypes.shiftval (GF?.t f)
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.to_poly (Lib.IntTypes.shift_right e n) ==
Vale.Math.Poly2_s.shift (Vale.Math.Poly2.Galois.to_poly e) (- Lib.IntTypes.uint_v n))
[SMTPat (... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Lib.IntTypes.shiftval",
"Spec.GaloisField.__proj__GF__item__t",
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.op_disEquality",
"Lib.IntTypes.U1",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Vale.Math.P... | [] | false | false | true | false | false | let lemma_shift_right f e n =
| let G.GF t irred = f in
let nf = I.bits t in
PL.lemma_index_all ();
PL.lemma_reverse_define_all ();
PL.lemma_shift_define_all ();
assert (I.uint_v (I.shift_right e n) == U.shift_right #nf (I.uint_v e) (I.uint_v n));
lemma_equal (to_poly (I.shift_right e n)) (shift (to_poly e) (- (I.uint_v n))) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.d | val d (a: poly) : (b: D.poly{poly == D.poly /\ coerce D.poly a == b}) | val d (a: poly) : (b: D.poly{poly == D.poly /\ coerce D.poly a == b}) | let d (a:poly) : (b:D.poly{poly == D.poly /\ coerce D.poly a == b}) =
reveal_defs ();
Vale.Math.Poly2_s.to_poly a | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 261,
"start_col": 0,
"start_line": 259
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly
-> b:
Vale.Math.Poly2.Defs_s.poly
{ Vale.Math.Poly2_s.poly == Vale.Math.Poly2.Defs_s.poly /\
Vale.Math.Poly2_s.coerce Vale.Math.Poly2.Defs_s.poly a == b } | Prims.Tot | [
"total"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2_s.to_poly",
"Prims.unit",
"Vale.Math.Poly2_s.reveal_defs",
"Vale.Math.Poly2.Defs_s.poly",
"Prims.l_and",
"Prims.eq2",
"Vale.Math.Poly2_s.coerce"
] | [] | false | false | false | false | false | let d (a: poly) : (b: D.poly{poly == D.poly /\ coerce D.poly a == b}) =
| reveal_defs ();
Vale.Math.Poly2_s.to_poly a | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.smul_rec | val smul_rec (a b m: poly) (n: nat) : Tot (poly & poly & poly) (decreases n) | val smul_rec (a b m: poly) (n: nat) : Tot (poly & poly & poly) (decreases n) | let rec smul_rec (a b m:poly) (n:nat) : Tot (poly & poly & poly) (decreases n) =
if n = 0 then (zero, a, b)
else
let (p, a, b) = smul_rec a b m (n - 1) in
let p = p +. (if b.[0] then a else zero) in
let a = mod_bit1 (shift a 1) m in // mod_bit1 is equivalent to mod in this case
let b = shift b (-1) ... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 211,
"start_col": 0,
"start_line": 204
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> Prims.Tot ((Vale.Math.Poly2_s.poly * Vale.Math.Poly2_s.poly) * Vale.Math.Poly2_s.poly) | Prims.Tot | [
"total",
""
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Mktuple3",
"Vale.Math.Poly2_s.zero",
"Prims.bool",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Vale.Math.Poly2.Galois.mod_bit1",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.op_String_Acces... | [
"recursion"
] | false | false | false | true | false | let rec smul_rec (a b m: poly) (n: nat) : Tot (poly & poly & poly) (decreases n) =
| if n = 0
then (zero, a, b)
else
let p, a, b = smul_rec a b m (n - 1) in
let p = p +. (if b.[ 0 ] then a else zero) in
let a = mod_bit1 (shift a 1) m in
let b = shift b (- 1) in
(p, a, b) | false |
Lib.ByteSequence.fst | Lib.ByteSequence.uints_to_bytes_le_nat_lemma_ | val uints_to_bytes_le_nat_lemma_: #t:inttype{unsigned t /\ ~(U1? t)} -> #l:secrecy_level
-> len:nat{len * numbytes t < pow2 32}
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len * numbytes t}
-> Lemma
(Seq.index (uints_to_bytes_le #t #l #len (nat_to_intseq_le #t #l len n)) i ==
Seq.index (nat_to_bytes... | val uints_to_bytes_le_nat_lemma_: #t:inttype{unsigned t /\ ~(U1? t)} -> #l:secrecy_level
-> len:nat{len * numbytes t < pow2 32}
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len * numbytes t}
-> Lemma
(Seq.index (uints_to_bytes_le #t #l #len (nat_to_intseq_le #t #l len n)) i ==
Seq.index (nat_to_bytes... | let uints_to_bytes_le_nat_lemma_ #t #l len n i =
let s:lseq (uint_t t l) len = nat_to_intseq_le #t #l len n in
calc (==) {
Seq.index (uints_to_bytes_le #t #l #len (nat_to_intseq_le #t #l len n)) i;
== { index_uints_to_bytes_le_aux #t #l len n i }
Seq.index (nat_to_bytes_le #l (numbytes t) (v s.[i / numb... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 665,
"start_col": 0,
"start_line": 657
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Prims.nat{len * Lib.IntTypes.numbytes t < Prims.pow2 32} ->
n: Prims.nat{n < Prims.pow2 (Lib.IntTypes.bits t * len)} ->
i: Prims.nat{i < len * Lib.IntTypes.numbytes t}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.index (Lib.ByteSequence.uints_to_bytes_le (Lib.ByteSequence.nat_to_intse... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.l_not",
"Lib.IntTypes.uu___is_U1",
"Lib.IntTypes.secrecy_level",
"Prims.nat",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Prims.pow2",
"Lib.IntTypes.bits",
"FStar.Calc.calc_finish",
... | [] | false | false | true | false | false | let uints_to_bytes_le_nat_lemma_ #t #l len n i =
| let s:lseq (uint_t t l) len = nat_to_intseq_le #t #l len n in
calc ( == ) {
Seq.index (uints_to_bytes_le #t #l #len (nat_to_intseq_le #t #l len n)) i;
( == ) { index_uints_to_bytes_le_aux #t #l len n i }
Seq.index (nat_to_bytes_le #l (numbytes t) (v s.[ i / numbytes t ])) (i % numbytes t);
( == ) { index_nat_to... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.fmul_iter | val fmul_iter: f: G.field -> i: nat{i < I.bits f.G.t - 1} -> fmul_t f -> fmul_t f | val fmul_iter: f: G.field -> i: nat{i < I.bits f.G.t - 1} -> fmul_t f -> fmul_t f | let fmul_iter (f:G.field) : i:nat{i < I.bits f.G.t - 1} -> fmul_t f -> fmul_t f =
fun i (p, a, b) ->
let b0 = I.eq_mask #f.G.t (I.logand b (G.one #f)) (G.one #f) in
let p = I.logxor p (I.logand b0 a) in
let carry_mask = I.eq_mask #f.G.t (I.shift_right a (I.size (I.bits f.G.t - 1))) (G.one #f) in
let a... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 231,
"start_col": 0,
"start_line": 223
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: Spec.GaloisField.field ->
i: Prims.nat{i < Lib.IntTypes.bits (GF?.t f) - 1} ->
_: Vale.Math.Poly2.Galois.fmul_t f
-> Vale.Math.Poly2.Galois.fmul_t f | Prims.Tot | [
"total"
] | [] | [
"Spec.GaloisField.field",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"Lib.IntTypes.bits",
"Spec.GaloisField.__proj__GF__item__t",
"Vale.Math.Poly2.Galois.fmul_t",
"Spec.GaloisField.felem",
"FStar.Pervasives.Native.Mktuple3",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",... | [] | false | false | false | false | false | let fmul_iter (f: G.field) : i: nat{i < I.bits f.G.t - 1} -> fmul_t f -> fmul_t f =
| fun i (p, a, b) ->
let b0 = I.eq_mask #f.G.t (I.logand b (G.one #f)) (G.one #f) in
let p = I.logxor p (I.logand b0 a) in
let carry_mask = I.eq_mask #f.G.t (I.shift_right a (I.size (I.bits f.G.t - 1))) (G.one #f) in
let a = I.shift_left a (I.size 1) in
let a = I.logxor a (I.logand carry_mask f.G.irred) in
le... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_pmul_k_left | val lemma_mul_pmul_k_left (a b: poly) (k: int) (n: nat) (n': int)
: Lemma (requires k + 1 <= n' /\ n' <= n)
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases (n - n')) | val lemma_mul_pmul_k_left (a b: poly) (k: int) (n: nat) (n': int)
: Lemma (requires k + 1 <= n' /\ n' <= n)
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases (n - n')) | let rec lemma_mul_pmul_k_left (a b:poly) (k:int) (n:nat) (n':int) : Lemma
(requires k + 1 <= n' /\ n' <= n)
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[k])
(decreases (n - n'))
=
PL.lemma_index_all ();
PL.lemma_shift_define_all ();
if n > n' then lemma_mul_pmul_k_left a b k n (... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 306,
"start_col": 0,
"start_line": 298
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Vale.Math.Poly2_s.poly ->
b: Vale.Math.Poly2_s.poly ->
k: Prims.int ->
n: Prims.nat ->
n': Prims.int
-> FStar.Pervasives.Lemma (requires k + 1 <= n' /\ n' <= n)
(ensures
Vale.Math.Poly2.Galois.sum_of_bools 0 n' (Vale.Math.Poly2.Galois.mul_element_fun a b k) ==
(Vale.Math.... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.int",
"Prims.nat",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_left",
"Prims.op_Addition",
"Prims.bool",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_base",
"Prims.unit",
"Vale.Math.Poly2.Lemmas.lemma_shift_define_all",
"Vale.Math.Poly2.Lemmas.le... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mul_pmul_k_left (a b: poly) (k: int) (n: nat) (n': int)
: Lemma (requires k + 1 <= n' /\ n' <= n)
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases (n - n')) =
| PL.lemma_index_all ();
PL.lemma_shift_define_all ();
if n > n' then lemma_mul_pmul_k_left a b k n (n' + 1) else lemma_mul_pmul_k_base a b k n | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.gmul_rec | val gmul_rec (f: G.field) (a b: G.felem f) (n: nat) : fmul_t f | val gmul_rec (f: G.field) (a b: G.felem f) (n: nat) : fmul_t f | let rec gmul_rec (f:G.field) (a b:G.felem f) (n:nat) : fmul_t f =
if n = 0 then (G.zero #f, a, b)
else
let (p, a, b) = gmul_rec f a b (n - 1) in
fmul_iter f 0 (p, a, b) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 237,
"start_col": 0,
"start_line": 233
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: Spec.GaloisField.field ->
a: Spec.GaloisField.felem f ->
b: Spec.GaloisField.felem f ->
n: Prims.nat
-> Vale.Math.Poly2.Galois.fmul_t f | Prims.Tot | [
"total"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Mktuple3",
"Spec.GaloisField.zero",
"Prims.bool",
"Vale.Math.Poly2.Galois.fmul_iter",
"Vale.Math.Poly2.Galois.fmul_t",
"Vale.Math.Poly2.Galois.gmul_rec",
"Prims.op_Subtra... | [
"recursion"
] | false | false | false | false | false | let rec gmul_rec (f: G.field) (a b: G.felem f) (n: nat) : fmul_t f =
| if n = 0
then (G.zero #f, a, b)
else
let p, a, b = gmul_rec f a b (n - 1) in
fmul_iter f 0 (p, a, b) | false |
Lib.ByteSequence.fst | Lib.ByteSequence.nat_from_intseq_be_public_to_secret | val nat_from_intseq_be_public_to_secret:
#t:inttype{unsigned t} -> len:size_pos{len * bits t < pow2 32} -> b:lseq (uint_t t PUB) len ->
Lemma (nat_from_intseq_be b == nat_from_intseq_be (map secret b)) | val nat_from_intseq_be_public_to_secret:
#t:inttype{unsigned t} -> len:size_pos{len * bits t < pow2 32} -> b:lseq (uint_t t PUB) len ->
Lemma (nat_from_intseq_be b == nat_from_intseq_be (map secret b)) | let rec nat_from_intseq_be_public_to_secret #t len b =
if len = 1 then begin
nat_from_intseq_be_lemma0 b;
nat_from_intseq_be_lemma0 (map secret b) end
else begin
let b_secret = map secret b in
let b1 = slice b 1 len in
let b1_secret = slice b_secret 1 len in
nat_from_intseq_be_public_to_secr... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 817,
"start_col": 0,
"start_line": 799
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Lib.IntTypes.size_pos{len * Lib.IntTypes.bits t < Prims.pow2 32} ->
b: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.PUB) len
-> FStar.Pervasives.Lemma
(ensures
Lib.ByteSequence.nat_from_intseq_be b ==
Lib.ByteSequence.nat_from_intseq_be (Lib.Sequence.map Lib.IntTypes.secret b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Lib.IntTypes.size_pos",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Prims.pow2",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.PUB",
"Prims.op_Equality",
"Prims.int",
"Lib.ByteSequence.nat_from_i... | [
"recursion"
] | false | false | true | false | false | let rec nat_from_intseq_be_public_to_secret #t len b =
| if len = 1
then
(nat_from_intseq_be_lemma0 b;
nat_from_intseq_be_lemma0 (map secret b))
else
let b_secret = map secret b in
let b1 = slice b 1 len in
let b1_secret = slice b_secret 1 len in
nat_from_intseq_be_public_to_secret #t (len - 1) b1;
nat_from_intseq_be_slice_lemma b 1;
nat_from_intseq_be_lemm... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.pmul_rec | val pmul_rec (a b: poly) (n: nat) : Tot poly (decreases n) | val pmul_rec (a b: poly) (n: nat) : Tot poly (decreases n) | let rec pmul_rec (a b:poly) (n:nat) : Tot poly (decreases n) =
if n = 0 then zero
else
let n' = n - 1 in
let p = pmul_rec a b n' in
if b.[n'] then p +. shift a n' else p | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 189,
"start_col": 0,
"start_line": 184
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> Prims.Tot Vale.Math.Poly2_s.poly | Prims.Tot | [
"total",
""
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Vale.Math.Poly2_s.zero",
"Prims.bool",
"Vale.Math.Poly2_s.op_String_Access",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.Galois.pmul_rec",
"Prims.op_Subtraction"
] | [
"recursion"
] | false | false | false | true | false | let rec pmul_rec (a b: poly) (n: nat) : Tot poly (decreases n) =
| if n = 0
then zero
else
let n' = n - 1 in
let p = pmul_rec a b n' in
if b.[ n' ] then p +. shift a n' else p | false |
GTWP.fst | GTWP.d_bind | val d_bind (#a #b #wc #wf: _) (c: m a D wc) (f: (x: a -> m b D (wf x))) : m b D (bind_wp wc wf) | val d_bind (#a #b #wc #wf: _) (c: m a D wc) (f: (x: a -> m b D (wf x))) : m b D (bind_wp wc wf) | let d_bind #a #b #wc #wf (c : m a D wc) (f : (x:a -> m b D (wf x))) : m b D (bind_wp wc wf) =
raise_val (fun () -> let y = downgrade_val c () in // cannot inline this
downgrade_val (f y) ()) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 49,
"start_col": 0,
"start_line": 47
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: GTWP.m a GTWP.D wc -> f: (x: a -> GTWP.m b GTWP.D (wf x)) -> GTWP.m b GTWP.D (GTWP.bind_wp wc wf) | Prims.Tot | [
"total"
] | [] | [
"GTWP.wp",
"GTWP.m",
"GTWP.D",
"FStar.Universe.raise_val",
"Prims.unit",
"GTWP.bind_wp",
"FStar.Universe.downgrade_val"
] | [] | false | false | false | false | false | let d_bind #a #b #wc #wf (c: m a D wc) (f: (x: a -> m b D (wf x))) : m b D (bind_wp wc wf) =
| raise_val (fun () ->
let y = downgrade_val c () in
downgrade_val (f y) ()) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_pmul_k_base | val lemma_mul_pmul_k_base (a b: poly) (k: int) (n: nat)
: Lemma (requires True)
(ensures sum_of_bools 0 n (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases n) | val lemma_mul_pmul_k_base (a b: poly) (k: int) (n: nat)
: Lemma (requires True)
(ensures sum_of_bools 0 n (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases n) | let rec lemma_mul_pmul_k_base (a b:poly) (k:int) (n:nat) : Lemma
(requires True)
(ensures sum_of_bools 0 n (mul_element_fun a b k) == (pmul_rec b a n).[k])
(decreases n)
=
PL.lemma_index_all ();
PL.lemma_add_define_all ();
PL.lemma_shift_define_all ();
if n > 0 then lemma_mul_pmul_k_base a b k (n - 1) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 296,
"start_col": 0,
"start_line": 288
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> k: Prims.int -> n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.sum_of_bools 0 n (Vale.Math.Poly2.Galois.mul_element_fun a b k) ==
(Vale.Math.Poly2.Galois.pmul_rec b a n).[ k ]) (decreases n) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.int",
"Prims.nat",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_base",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.unit",
"Vale.Math.Poly2.Lemmas.lemma_shift_define_all",
"Vale.Math.Poly2.Lemmas.lemma_add_define_all",
"Vale.Math.Poly2.Lemmas.... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mul_pmul_k_base (a b: poly) (k: int) (n: nat)
: Lemma (requires True)
(ensures sum_of_bools 0 n (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases n) =
| PL.lemma_index_all ();
PL.lemma_add_define_all ();
PL.lemma_shift_define_all ();
if n > 0 then lemma_mul_pmul_k_base a b k (n - 1) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_element_rec | val lemma_mul_element_rec (a b: poly) (k n: int)
: Lemma
(sum_of_bools 0 n (mul_element_fun a b k) == sum_of_bools 0 n (D.mul_element_fun (d a) (d b) k)) | val lemma_mul_element_rec (a b: poly) (k n: int)
: Lemma
(sum_of_bools 0 n (mul_element_fun a b k) == sum_of_bools 0 n (D.mul_element_fun (d a) (d b) k)) | let rec lemma_mul_element_rec (a b:poly) (k:int) (n:int) : Lemma
(sum_of_bools 0 n (mul_element_fun a b k) == sum_of_bools 0 n (D.mul_element_fun (d a) (d b) k))
=
reveal_defs ();
if n > 0 then lemma_mul_element_rec a b k (n - 1) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 267,
"start_col": 0,
"start_line": 263
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> k: Prims.int -> n: Prims.int
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.sum_of_bools 0 n (Vale.Math.Poly2.Galois.mul_element_fun a b k) ==
Vale.Math.Poly2.Galois.sum_of_bools 0
n
(Vale.Math.Poly2.Defs_s.mul_elemen... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.int",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.Galois.lemma_mul_element_rec",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.unit",
"Vale.Math.Poly2_s.reveal_defs",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Galois.sum_of_bools",
"Vale.Math.P... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mul_element_rec (a b: poly) (k n: int)
: Lemma
(sum_of_bools 0 n (mul_element_fun a b k) == sum_of_bools 0 n (D.mul_element_fun (d a) (d b) k)) =
| reveal_defs ();
if n > 0 then lemma_mul_element_rec a b k (n - 1) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.gmul | val gmul (f: G.field) (a b: G.felem f) : G.felem f | val gmul (f: G.field) (a b: G.felem f) : G.felem f | let gmul (f:G.field) (a b:G.felem f) : G.felem f =
let (p, _, _) = gmul_rec f a b (I.bits f.G.t) in
p | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 241,
"start_col": 0,
"start_line": 239
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> a: Spec.GaloisField.felem f -> b: Spec.GaloisField.felem f
-> Spec.GaloisField.felem f | Prims.Tot | [
"total"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Vale.Math.Poly2.Galois.fmul_t",
"Vale.Math.Poly2.Galois.gmul_rec",
"Lib.IntTypes.bits",
"Spec.GaloisField.__proj__GF__item__t"
] | [] | false | false | false | false | false | let gmul (f: G.field) (a b: G.felem f) : G.felem f =
| let p, _, _ = gmul_rec f a b (I.bits f.G.t) in
p | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_def | val lemma_mul_def (a b: poly) : Lemma (mul_def a b == mul a b) | val lemma_mul_def (a b: poly) : Lemma (mul_def a b == mul a b) | let lemma_mul_def (a b:poly) : Lemma
(mul_def a b == mul a b)
=
reveal_defs ();
PL.lemma_pointwise_equal (mul_def a b) (mul a b) (lemma_mul_element a b) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 280,
"start_col": 0,
"start_line": 276
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(ensures Vale.Math.Poly2.Galois.mul_def a b == Vale.Math.Poly2_s.mul a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Lemmas.lemma_pointwise_equal",
"Vale.Math.Poly2.Galois.mul_def",
"Vale.Math.Poly2_s.mul",
"Vale.Math.Poly2.Galois.lemma_mul_element",
"Prims.unit",
"Vale.Math.Poly2_s.reveal_defs",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Perva... | [] | true | false | true | false | false | let lemma_mul_def (a b: poly) : Lemma (mul_def a b == mul a b) =
| reveal_defs ();
PL.lemma_pointwise_equal (mul_def a b) (mul a b) (lemma_mul_element a b) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.fmul | val fmul (f: G.field) (a b: G.felem f) : G.felem f | val fmul (f: G.field) (a b: G.felem f) : G.felem f | let fmul (f:G.field) (a b:G.felem f) : G.felem f =
let one = G.one #f in
let zero = G.zero #f in
let (p, a, b) =
Lib.LoopCombinators.repeati (I.bits f.G.t - 1)
(fmul_iter f)
(zero, a, b)
in
let b0 = I.eq_mask #f.G.t (I.logand b (G.one #f)) (G.one #f) in
let p = I.logxor p (I.logand b0 a) in
... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 253,
"start_col": 0,
"start_line": 243
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> a: Spec.GaloisField.felem f -> b: Spec.GaloisField.felem f
-> Spec.GaloisField.felem f | Prims.Tot | [
"total"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Lib.IntTypes.int_t",
"Spec.GaloisField.__proj__GF__item__t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logxor",
"Lib.IntTypes.logand",
"Lib.IntTypes.eq_mask",
"Spec.GaloisField.one",
"FStar.Pervasives.Native.tuple3",
"Lib.LoopCombinators.repeati",
"... | [] | false | false | false | false | false | let fmul (f: G.field) (a b: G.felem f) : G.felem f =
| let one = G.one #f in
let zero = G.zero #f in
let p, a, b = Lib.LoopCombinators.repeati (I.bits f.G.t - 1) (fmul_iter f) (zero, a, b) in
let b0 = I.eq_mask #f.G.t (I.logand b (G.one #f)) (G.one #f) in
let p = I.logxor p (I.logand b0 a) in
p | false |
Lib.ByteSequence.fst | Lib.ByteSequence.nat_from_intseq_be_slice_lemma_ | val nat_from_intseq_be_slice_lemma_:
#t:inttype{unsigned t} -> #l:secrecy_level -> #len:size_nat
-> b:lseq (int_t t l) len
-> i:nat{i <= len} ->
Lemma (ensures (nat_from_intseq_be_ b == nat_from_intseq_be_ (slice b i len) + pow2 ((len - i) * bits t) * nat_from_intseq_be_ (slice b 0 i)))
(decreases (len - i)... | val nat_from_intseq_be_slice_lemma_:
#t:inttype{unsigned t} -> #l:secrecy_level -> #len:size_nat
-> b:lseq (int_t t l) len
-> i:nat{i <= len} ->
Lemma (ensures (nat_from_intseq_be_ b == nat_from_intseq_be_ (slice b i len) + pow2 ((len - i) * bits t) * nat_from_intseq_be_ (slice b 0 i)))
(decreases (len - i)... | let rec nat_from_intseq_be_slice_lemma_ #t #l #len b i =
if len = 0 then ()
else begin
if i = len then ()
else begin
let b1 = slice b i len in
nat_from_intseq_be_slice_lemma_ #t #l #(len - i) b1 1;
assert (nat_from_intseq_be_ b1 == nat_from_intseq_be_ (slice b (i + 1) len) + pow2 ((len - i... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 411,
"start_col": 0,
"start_line": 399
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: Lib.Sequence.lseq (Lib.IntTypes.int_t t l) len -> i: Prims.nat{i <= len}
-> FStar.Pervasives.Lemma
(ensures
Lib.ByteSequence.nat_from_intseq_be_ b ==
Lib.ByteSequence.nat_from_intseq_be_ (Lib.Sequence.slice b i len) +
Prims.pow2 ((len - i) * Lib.IntTypes.bits t) *
Lib.ByteSequ... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Lib.IntTypes.inttype",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Lib.IntTypes.secrecy_level",
"Lib.IntTypes.size_nat",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.l_or",
"Lib.IntTypes.max_size_t",
... | [
"recursion"
] | false | false | true | false | false | let rec nat_from_intseq_be_slice_lemma_ #t #l #len b i =
| if len = 0
then ()
else
if i = len
then ()
else
let b1 = slice b i len in
nat_from_intseq_be_slice_lemma_ #t #l #(len - i) b1 1;
assert (nat_from_intseq_be_ b1 ==
nat_from_intseq_be_ (slice b (i + 1) len) + pow2 ((len - i - 1) * bits t) * v b.[ i ]);
nat_from_intseq_be_slice_lemma_ #t #l #... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_pmul | val lemma_mul_pmul (a b: poly) : Lemma (mul_def a b == pmul b a) | val lemma_mul_pmul (a b: poly) : Lemma (mul_def a b == pmul b a) | let lemma_mul_pmul (a b:poly) : Lemma
(mul_def a b == pmul b a)
=
PL.lemma_pointwise_equal (mul_def a b) (pmul b a) (lemma_mul_pmul_k a b) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 331,
"start_col": 0,
"start_line": 328
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(ensures Vale.Math.Poly2.Galois.mul_def a b == Vale.Math.Poly2.Galois.pmul b a) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Lemmas.lemma_pointwise_equal",
"Vale.Math.Poly2.Galois.mul_def",
"Vale.Math.Poly2.Galois.pmul",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_mul_pmul (a b: poly) : Lemma (mul_def a b == pmul b a) =
| PL.lemma_pointwise_equal (mul_def a b) (pmul b a) (lemma_mul_pmul_k a b) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mmul_pmul | val lemma_mmul_pmul (a b m: poly) (n: nat)
: Lemma (requires poly_length m > 0 /\ n >= poly_length b)
(ensures mod (mmul a b m n) m == mod (pmul a b) m) | val lemma_mmul_pmul (a b m: poly) (n: nat)
: Lemma (requires poly_length m > 0 /\ n >= poly_length b)
(ensures mod (mmul a b m n) m == mod (pmul a b) m) | let rec lemma_mmul_pmul (a b m:poly) (n:nat) : Lemma
(requires poly_length m > 0 /\ n >= poly_length b)
(ensures mod (mmul a b m n) m == mod (pmul a b) m)
=
PL.lemma_index_all ();
if n = poly_length b then lemma_mmul_pmul_rec a b m n
else lemma_mmul_pmul a b m (n - 1) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 362,
"start_col": 0,
"start_line": 356
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
Vale.Math.Poly2.Galois.poly_length m > 0 /\ n >= Vale.Math.Poly2.Galois.poly_length b)
(ensures
Vale.Math.Poly2_s.mod (Vale.Math.Poly2.Galois.mmul a b m n... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_Equality",
"Vale.Math.Poly2.Galois.poly_length",
"Vale.Math.Poly2.Galois.lemma_mmul_pmul_rec",
"Prims.bool",
"Vale.Math.Poly2.Galois.lemma_mmul_pmul",
"Prims.op_Subtraction",
"Prims.unit",
"Vale.Math.Poly2.Lemmas.lemma_index_all",
"Prims.l_and",
... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mmul_pmul (a b m: poly) (n: nat)
: Lemma (requires poly_length m > 0 /\ n >= poly_length b)
(ensures mod (mmul a b m n) m == mod (pmul a b) m) =
| PL.lemma_index_all ();
if n = poly_length b then lemma_mmul_pmul_rec a b m n else lemma_mmul_pmul a b m (n - 1) | false |
Lib.ByteSequence.fst | Lib.ByteSequence.uints_to_bytes_be_nat_lemma_ | val uints_to_bytes_be_nat_lemma_: #t:inttype{unsigned t /\ ~(U1? t)} -> #l:secrecy_level
-> len:nat{len * numbytes t < pow2 32}
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len * numbytes t}
-> Lemma
(Seq.index (uints_to_bytes_be #t #l #len (nat_to_intseq_be #t #l len n)) i ==
Seq.index (nat_to_bytes... | val uints_to_bytes_be_nat_lemma_: #t:inttype{unsigned t /\ ~(U1? t)} -> #l:secrecy_level
-> len:nat{len * numbytes t < pow2 32}
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len * numbytes t}
-> Lemma
(Seq.index (uints_to_bytes_be #t #l #len (nat_to_intseq_be #t #l len n)) i ==
Seq.index (nat_to_bytes... | let uints_to_bytes_be_nat_lemma_ #t #l len n i =
let s:lseq (uint_t t l) len = nat_to_intseq_be #t #l len n in
calc (==) {
Seq.index (uints_to_bytes_be #t #l #len (nat_to_intseq_be #t #l len n)) i;
== { index_uints_to_bytes_be_aux #t #l len n i }
Seq.index (nat_to_bytes_be #l (numbytes t) (v s.[i / numb... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 713,
"start_col": 0,
"start_line": 705
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Prims.nat{len * Lib.IntTypes.numbytes t < Prims.pow2 32} ->
n: Prims.nat{n < Prims.pow2 (Lib.IntTypes.bits t * len)} ->
i: Prims.nat{i < len * Lib.IntTypes.numbytes t}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.index (Lib.ByteSequence.uints_to_bytes_be (Lib.ByteSequence.nat_to_intse... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.l_not",
"Lib.IntTypes.uu___is_U1",
"Lib.IntTypes.secrecy_level",
"Prims.nat",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Prims.pow2",
"Lib.IntTypes.bits",
"FStar.Calc.calc_finish",
... | [] | false | false | true | false | false | let uints_to_bytes_be_nat_lemma_ #t #l len n i =
| let s:lseq (uint_t t l) len = nat_to_intseq_be #t #l len n in
calc ( == ) {
Seq.index (uints_to_bytes_be #t #l #len (nat_to_intseq_be #t #l len n)) i;
( == ) { index_uints_to_bytes_be_aux #t #l len n i }
Seq.index (nat_to_bytes_be #l (numbytes t) (v s.[ i / numbytes t ])) (i % numbytes t);
( == ) { index_nat_to... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_pmul_degree | val lemma_pmul_degree (a b: poly) (n: nat)
: Lemma (requires True) (ensures poly_length (pmul_rec a b n) <= poly_length a + n) | val lemma_pmul_degree (a b: poly) (n: nat)
: Lemma (requires True) (ensures poly_length (pmul_rec a b n) <= poly_length a + n) | let rec lemma_pmul_degree (a b:poly) (n:nat) : Lemma
(requires True)
(ensures poly_length (pmul_rec a b n) <= poly_length a + n)
=
if n > 0 then lemma_pmul_degree a b (n - 1) | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 286,
"start_col": 0,
"start_line": 282
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.poly_length (Vale.Math.Poly2.Galois.pmul_rec a b n) <=
Vale.Math.Poly2.Galois.poly_length a + n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.Galois.lemma_pmul_degree",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Vale.Math.Poly2.Galois.poly_length",
"Vale.Math.Poly2.Galoi... | [
"recursion"
] | false | false | true | false | false | let rec lemma_pmul_degree (a b: poly) (n: nat)
: Lemma (requires True) (ensures poly_length (pmul_rec a b n) <= poly_length a + n) =
| if n > 0 then lemma_pmul_degree a b (n - 1) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_element | val lemma_mul_element (a b: poly) (k: int)
: Lemma (mul_element a b k == D.mul_element (d a) (d b) k) | val lemma_mul_element (a b: poly) (k: int)
: Lemma (mul_element a b k == D.mul_element (d a) (d b) k) | let lemma_mul_element (a b:poly) (k:int) : Lemma
(mul_element a b k == D.mul_element (d a) (d b) k)
=
reveal_defs ();
lemma_mul_element_rec a b k (k + 1);
() | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 274,
"start_col": 0,
"start_line": 269
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> k: Prims.int
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.mul_element a b k ==
Vale.Math.Poly2.Defs_s.mul_element (Vale.Math.Poly2.Galois.d a) (Vale.Math.Poly2.Galois.d b) k
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.int",
"Prims.unit",
"Vale.Math.Poly2.Galois.lemma_mul_element_rec",
"Prims.op_Addition",
"Vale.Math.Poly2_s.reveal_defs",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Galois.mul_element",
"Vale.Math.Poly2.Defs_s.mul_element",
"V... | [] | true | false | true | false | false | let lemma_mul_element (a b: poly) (k: int)
: Lemma (mul_element a b k == D.mul_element (d a) (d b) k) =
| reveal_defs ();
lemma_mul_element_rec a b k (k + 1);
() | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_pmul_k_right | val lemma_mul_pmul_k_right (a b: poly) (k: int) (n n': nat)
: Lemma (requires n == poly_length a /\ n <= n')
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases n') | val lemma_mul_pmul_k_right (a b: poly) (k: int) (n n': nat)
: Lemma (requires n == poly_length a /\ n <= n')
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases n') | let rec lemma_mul_pmul_k_right (a b:poly) (k:int) (n n':nat) : Lemma
(requires n == poly_length a /\ n <= n')
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[k])
(decreases n')
=
PL.lemma_index_all ();
PL.lemma_shift_define_all ();
if n' > n then lemma_mul_pmul_k_right a b k n (n' ... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 316,
"start_col": 0,
"start_line": 308
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Vale.Math.Poly2_s.poly ->
b: Vale.Math.Poly2_s.poly ->
k: Prims.int ->
n: Prims.nat ->
n': Prims.nat
-> FStar.Pervasives.Lemma (requires n == Vale.Math.Poly2.Galois.poly_length a /\ n <= n')
(ensures
Vale.Math.Poly2.Galois.sum_of_bools 0 n' (Vale.Math.Poly2.Galois.mul_element_fun... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.int",
"Prims.nat",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_right",
"Prims.op_Subtraction",
"Prims.bool",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_base",
"Prims.unit",
"Vale.Math.Poly2.Lemmas.lemma_shift_define_all",
"Vale.Math.Poly2.Lemma... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mul_pmul_k_right (a b: poly) (k: int) (n n': nat)
: Lemma (requires n == poly_length a /\ n <= n')
(ensures sum_of_bools 0 n' (mul_element_fun a b k) == (pmul_rec b a n).[ k ])
(decreases n') =
| PL.lemma_index_all ();
PL.lemma_shift_define_all ();
if n' > n then lemma_mul_pmul_k_right a b k n (n' - 1) else lemma_mul_pmul_k_base a b k n | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mod_bit1 | val lemma_mod_bit1 (a m: poly)
: Lemma (requires poly_length a <= poly_length m /\ 0 <= degree m)
(ensures mod_bit1 a m == a %. m) | val lemma_mod_bit1 (a m: poly)
: Lemma (requires poly_length a <= poly_length m /\ 0 <= degree m)
(ensures mod_bit1 a m == a %. m) | let lemma_mod_bit1 (a m:poly) : Lemma
(requires poly_length a <= poly_length m /\ 0 <= degree m)
(ensures mod_bit1 a m == a %. m)
=
PL.lemma_index_all ();
PL.lemma_add_define_all ();
let n = poly_length m in
if (poly_length a < n) then PL.lemma_mod_small a m
else
(
lemma_degree a;
lemma_degree... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 383,
"start_col": 0,
"start_line": 364
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly
-> FStar.Pervasives.Lemma
(requires
Vale.Math.Poly2.Galois.poly_length a <= Vale.Math.Poly2.Galois.poly_length m /\
0 <= Vale.Math.Poly2_s.degree m) (ensures Vale.Math.Poly2.Galois.mod_bit1 a m == a %. m) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.op_LessThan",
"Vale.Math.Poly2.Galois.poly_length",
"Vale.Math.Poly2.Lemmas.lemma_mod_small",
"Prims.bool",
"Prims.unit",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.lemma_add_zero",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2.Lemmas.lemma_mod_cancel",
... | [] | false | false | true | false | false | let lemma_mod_bit1 (a m: poly)
: Lemma (requires poly_length a <= poly_length m /\ 0 <= degree m)
(ensures mod_bit1 a m == a %. m) =
| PL.lemma_index_all ();
PL.lemma_add_define_all ();
let n = poly_length m in
if (poly_length a < n)
then PL.lemma_mod_small a m
else
(lemma_degree a;
lemma_degree m;
lemma_degree (a +. m);
PL.lemma_mod_distribute a m m;
PL.lemma_mod_cancel m;
lemma_add_zero (a %. m);
PL.lemma_mod_small (a +. m)... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mmul_smul_rec | val lemma_mmul_smul_rec (a b m: poly) (n: nat)
: Lemma (requires degree m >= 0 /\ degree a < degree m)
(ensures
smul_rec a b m n == (mmul a b m n, shift a n %. m, shift b (- n)) /\
mmul a b m n == mmul a b m n %. m) | val lemma_mmul_smul_rec (a b m: poly) (n: nat)
: Lemma (requires degree m >= 0 /\ degree a < degree m)
(ensures
smul_rec a b m n == (mmul a b m n, shift a n %. m, shift b (- n)) /\
mmul a b m n == mmul a b m n %. m) | let rec lemma_mmul_smul_rec (a b m:poly) (n:nat) : Lemma
(requires degree m >= 0 /\ degree a < degree m)
(ensures
smul_rec a b m n == (mmul a b m n, shift a n %. m, shift b (-n)) /\
mmul a b m n == mmul a b m n %. m
)
=
PL.lemma_index_all ();
PL.lemma_shift_define_all ();
PL.lemma_mod_small a m;
... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 444,
"start_col": 0,
"start_line": 413
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
Vale.Math.Poly2_s.degree m >= 0 /\ Vale.Math.Poly2_s.degree a < Vale.Math.Poly2_s.degree m)
(ensures
Vale.Math.Poly2.Galois.smul_rec a b m n ==
(V... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.unit",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.lemma_add_zero",
"Vale.Math.Poly2.Galois.lemma_mod_bit1",
"Vale.Math.Poly2.Lemmas.lemma_mod_mod",
"Vale.Math.Poly2.Lemmas.lemm... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mmul_smul_rec (a b m: poly) (n: nat)
: Lemma (requires degree m >= 0 /\ degree a < degree m)
(ensures
smul_rec a b m n == (mmul a b m n, shift a n %. m, shift b (- n)) /\
mmul a b m n == mmul a b m n %. m) =
| PL.lemma_index_all ();
PL.lemma_shift_define_all ();
PL.lemma_mod_small a m;
PL.lemma_mod_small zero m;
lemma_equal (shift a 0) a;
let p0, a0, b0 = smul_rec a b m n in
if n > 0
then
(let n1 = n - 1 in
let p1, a1, b1 = smul_rec a b m n1 in
lemma_mmul_smul_rec a b m n1;
PL.lemma_shift_shift b (- n1) (- 1);
... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul_pmul_k | val lemma_mul_pmul_k (a b: poly) (k: int) : Lemma ((mul_def a b).[ k ] == (pmul b a).[ k ]) | val lemma_mul_pmul_k (a b: poly) (k: int) : Lemma ((mul_def a b).[ k ] == (pmul b a).[ k ]) | let lemma_mul_pmul_k (a b:poly) (k:int) : Lemma
((mul_def a b).[k] == (pmul b a).[k])
=
PL.lemma_index_all ();
let n = poly_length a in
lemma_pmul_degree b a n;
if n = k + 1 then lemma_mul_pmul_k_base a b k n
else if n > k + 1 then lemma_mul_pmul_k_left a b k n (k + 1)
else lemma_mul_pmul_k_right a b k ... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 326,
"start_col": 0,
"start_line": 318
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> k: Prims.int
-> FStar.Pervasives.Lemma
(ensures (Vale.Math.Poly2.Galois.mul_def a b).[ k ] == (Vale.Math.Poly2.Galois.pmul b a).[ k ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.int",
"Prims.op_Equality",
"Prims.op_Addition",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_base",
"Prims.bool",
"Prims.op_GreaterThan",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_left",
"Vale.Math.Poly2.Galois.lemma_mul_pmul_k_right",
"Prims.unit",
"Vale.Math.Poly2.G... | [] | false | false | true | false | false | let lemma_mul_pmul_k (a b: poly) (k: int) : Lemma ((mul_def a b).[ k ] == (pmul b a).[ k ]) =
| PL.lemma_index_all ();
let n = poly_length a in
lemma_pmul_degree b a n;
if n = k + 1
then lemma_mul_pmul_k_base a b k n
else
if n > k + 1
then lemma_mul_pmul_k_left a b k n (k + 1)
else lemma_mul_pmul_k_right a b k n (k + 1) | false |
GTWP.fst | GTWP.app | val app (#a #b #i #wp: _) (f: (a -> GTD b i wp)) (x: a) : GTD b i wp | val app (#a #b #i #wp: _) (f: (a -> GTD b i wp)) (x: a) : GTD b i wp | let app #a #b #i #wp (f : a -> GTD b i wp) (x : a) : GTD b i wp = f x | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 137,
"start_col": 0,
"start_line": 137
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> GTWP.GTD b) -> x: a -> GTWP.GTD b | GTWP.GTD | [] | [] | [
"GTWP.idx",
"GTWP.wp"
] | [] | false | true | false | false | false | let app #a #b #i #wp (f: (a -> GTD b i wp)) (x: a) : GTD b i wp =
| f x | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mmul_smul | val lemma_mmul_smul (a b m: poly) (n: nat)
: Lemma (requires degree m >= 0 /\ degree a < degree m) (ensures smul a b m n == mmul a b m n) | val lemma_mmul_smul (a b m: poly) (n: nat)
: Lemma (requires degree m >= 0 /\ degree a < degree m) (ensures smul a b m n == mmul a b m n) | let lemma_mmul_smul (a b m:poly) (n:nat) : Lemma
(requires degree m >= 0 /\ degree a < degree m)
(ensures smul a b m n == mmul a b m n)
=
lemma_mmul_smul_rec a b m n | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 450,
"start_col": 0,
"start_line": 446
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
Vale.Math.Poly2_s.degree m >= 0 /\ Vale.Math.Poly2_s.degree a < Vale.Math.Poly2_s.degree m)
(ensures Vale.Math.Poly2.Galois.smul a b m n == Vale.Math.Poly2.Galois... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Vale.Math.Poly2.Galois.lemma_mmul_smul_rec",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Vale.Math.Poly2_s.degree",
"Prims.op_LessThan",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Galois.smul",
"Vale.Math.Poly2.Galois.m... | [] | true | false | true | false | false | let lemma_mmul_smul (a b m: poly) (n: nat)
: Lemma (requires degree m >= 0 /\ degree a < degree m) (ensures smul a b m n == mmul a b m n) =
| lemma_mmul_smul_rec a b m n | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mmul_pmul_rec | val lemma_mmul_pmul_rec (a b m: poly) (n: nat)
: Lemma (requires poly_length m > 0) (ensures mod (mmul a b m n) m == mod (pmul_rec a b n) m) | val lemma_mmul_pmul_rec (a b m: poly) (n: nat)
: Lemma (requires poly_length m > 0) (ensures mod (mmul a b m n) m == mod (pmul_rec a b n) m) | let rec lemma_mmul_pmul_rec (a b m:poly) (n:nat) : Lemma
(requires poly_length m > 0)
(ensures mod (mmul a b m n) m == mod (pmul_rec a b n) m)
=
if n > 0 then
(
let n' = n - 1 in
let mp = mmul a b m n' in
let pp = pmul_rec a b n' in
lemma_mmul_pmul_rec a b m (n - 1);
assert (mod mp m == mo... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 354,
"start_col": 0,
"start_line": 333
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma (requires Vale.Math.Poly2.Galois.poly_length m > 0)
(ensures
Vale.Math.Poly2_s.mod (Vale.Math.Poly2.Galois.mmul a b m n) m ==
Vale.Math.Poly2_s.mod (Vale.Math.Poly2.Galoi... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_GreaterThan",
"Prims.unit",
"Vale.Math.Poly2.Lemmas.lemma_mod_mod",
"Vale.Math.Poly2.Lemmas.lemma_mod_distribute",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2_s.shift",
"Prims._assert",
"Prims.eq2",
"Vale.Math.Poly2_s.mod",
"Vale.Math.Pol... | [
"recursion"
] | false | false | true | false | false | let rec lemma_mmul_pmul_rec (a b m: poly) (n: nat)
: Lemma (requires poly_length m > 0) (ensures mod (mmul a b m n) m == mod (pmul_rec a b n) m) =
| if n > 0
then
(let n' = n - 1 in
let mp = mmul a b m n' in
let pp = pmul_rec a b n' in
lemma_mmul_pmul_rec a b m (n - 1);
assert (mod mp m == mod pp m);
let s = shift a n' in
PL.lemma_mod_distribute pp s m;
PL.lemma_mod_distribute mp s m;
PL.lemma_mod_distribute mp (s %. m) m;
PL.l... | false |
GTWP.fst | GTWP.labs0 | val labs0 (#i: _) (n: int) : Gtd int i | val labs0 (#i: _) (n: int) : Gtd int i | let labs0 #i (n:int) : Gtd int i =
if n < 0
then -n
else n | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 157,
"start_col": 0,
"start_line": 154
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.int -> GTWP.Gtd Prims.int | GTWP.Gtd | [] | [] | [
"GTWP.idx",
"Prims.int",
"Prims.op_LessThan",
"Prims.op_Minus",
"Prims.bool"
] | [] | false | true | false | false | false | let labs0 #i (n: int) : Gtd int i =
| if n < 0 then - n else n | false |
GTWP.fst | GTWP.coerce | val coerce (#a #b: _) (x: a{a == b}) : b | val coerce (#a #b: _) (x: a{a == b}) : b | let coerce #a #b (x:a{a == b}) : b = x | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 13,
"start_col": 0,
"start_line": 13
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a{a == b} -> b | Prims.Tot | [
"total"
] | [] | [
"Prims.eq2"
] | [] | false | false | false | false | false | let coerce #a #b (x: a{a == b}) : b =
| x | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.mmul | val mmul (a b m: poly) (n: nat) : Tot poly (decreases n) | val mmul (a b m: poly) (n: nat) : Tot poly (decreases n) | let rec mmul (a b m:poly) (n:nat) : Tot poly (decreases n) =
if n = 0 then zero
else
let n' = n - 1 in
let p = mmul a b m n' in
if b.[n'] then p +. (shift a n' %. m) else p | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 199,
"start_col": 0,
"start_line": 194
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> b: Vale.Math.Poly2_s.poly -> m: Vale.Math.Poly2_s.poly -> n: Prims.nat
-> Prims.Tot Vale.Math.Poly2_s.poly | Prims.Tot | [
"total",
""
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Vale.Math.Poly2_s.zero",
"Prims.bool",
"Vale.Math.Poly2_s.op_String_Access",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2.op_Percent_Dot",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.Galois.mmul",
"Prims.op_Subtractio... | [
"recursion"
] | false | false | false | true | false | let rec mmul (a b m: poly) (n: nat) : Tot poly (decreases n) =
| if n = 0
then zero
else
let n' = n - 1 in
let p = mmul a b m n' in
if b.[ n' ] then p +. (shift a n' %. m) else p | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mod_shift1 | val lemma_mod_shift1 (a irred: poly) (k: nat)
: Lemma (requires degree a < k /\ degree irred < k)
(ensures
mod_bit1 (shift a 1) (monomial k +. irred) == mod_shift1 a irred k /\
(shift a (1 - k) == one <==> a.[ k - 1 ])) | val lemma_mod_shift1 (a irred: poly) (k: nat)
: Lemma (requires degree a < k /\ degree irred < k)
(ensures
mod_bit1 (shift a 1) (monomial k +. irred) == mod_shift1 a irred k /\
(shift a (1 - k) == one <==> a.[ k - 1 ])) | let lemma_mod_shift1 (a irred:poly) (k:nat) : Lemma
(requires degree a < k /\ degree irred < k)
(ensures mod_bit1 (shift a 1) (monomial k +. irred) == mod_shift1 a irred k /\ (shift a (1 - k) == one <==> a.[k - 1]))
=
let m = monomial k +. irred in
let s = shift a 1 %. monomial k in
PL.lemma_index_all ();
... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 411,
"start_col": 0,
"start_line": 385
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Vale.Math.Poly2_s.poly -> irred: Vale.Math.Poly2_s.poly -> k: Prims.nat
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2_s.degree a < k /\ Vale.Math.Poly2_s.degree irred < k)
(ensures
Vale.Math.Poly2.Galois.mod_bit1 (Vale.Math.Poly2_s.shift a 1)
(Vale.Math.Poly2_s.monomial k +. irr... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.unit",
"Vale.Math.Poly2_s.op_String_Access",
"Prims.op_Subtraction",
"Vale.Math.Poly2.lemma_equal",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2_s.one",
"Prims.bool",
"Vale.Math.Poly2.Galois.mod_bit1",
"Vale.Math.Poly2.Galois.mod_shift1",
"Vale.Math... | [] | false | false | true | false | false | let lemma_mod_shift1 (a irred: poly) (k: nat)
: Lemma (requires degree a < k /\ degree irred < k)
(ensures
mod_bit1 (shift a 1) (monomial k +. irred) == mod_shift1 a irred k /\
(shift a (1 - k) == one <==> a.[ k - 1 ])) =
| let m = monomial k +. irred in
let s = shift a 1 %. monomial k in
PL.lemma_index_all ();
PL.lemma_add_define_all ();
PL.lemma_shift_define_all ();
PL.lemma_monomial_define k;
PL.lemma_one_define ();
assert (m.[ k ]);
PL.lemma_mod_monomial (shift a 1) k;
if a.[ k - 1 ]
then
(lemma_equal s (shift a 1 +. monomial k);
... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_eqmask_and | val lemma_eqmask_and (t: I.inttype{Lib.IntTypes.unsigned t}) (a b c: I.uint_t t I.SEC)
: Lemma (requires t =!= Lib.IntTypes.U1)
(ensures I.v (I.logand (I.eq_mask a b) c) == (if I.v a = I.v b then I.v c else 0)) | val lemma_eqmask_and (t: I.inttype{Lib.IntTypes.unsigned t}) (a b c: I.uint_t t I.SEC)
: Lemma (requires t =!= Lib.IntTypes.U1)
(ensures I.v (I.logand (I.eq_mask a b) c) == (if I.v a = I.v b then I.v c else 0)) | let lemma_eqmask_and (t:I.inttype{Lib.IntTypes.unsigned t}) (a b c:I.uint_t t I.SEC) : Lemma
(requires t =!= Lib.IntTypes.U1)
(ensures I.v (I.logand (I.eq_mask a b) c) == (if I.v a = I.v b then I.v c else 0))
=
GI.define_eq_mask t a b;
GI.define_logand t (I.eq_mask a b) c;
U.logand_commutative #(I.bits t) (... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 461,
"start_col": 0,
"start_line": 452
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: Lib.IntTypes.inttype{Lib.IntTypes.unsigned t} ->
a: Lib.IntTypes.uint_t t Lib.IntTypes.SEC ->
b: Lib.IntTypes.uint_t t Lib.IntTypes.SEC ->
c: Lib.IntTypes.uint_t t Lib.IntTypes.SEC
-> FStar.Pervasives.Lemma (requires ~(t == Lib.IntTypes.U1))
(ensures
Lib.IntTypes.v (Lib.IntTypes.loga... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.UInt.logand_lemma_2",
"Lib.IntTypes.bits",
"Lib.IntTypes.v",
"FStar.UInt.logand_lemma_1",
"FStar.UInt.logand_commutative",
"Lib.IntTypes.eq_mask",
"Vale.Math.Poly2.Ga... | [] | true | false | true | false | false | let lemma_eqmask_and (t: I.inttype{Lib.IntTypes.unsigned t}) (a b c: I.uint_t t I.SEC)
: Lemma (requires t =!= Lib.IntTypes.U1)
(ensures I.v (I.logand (I.eq_mask a b) c) == (if I.v a = I.v b then I.v c else 0)) =
| GI.define_eq_mask t a b;
GI.define_logand t (I.eq_mask a b) c;
U.logand_commutative #(I.bits t) (I.v (I.eq_mask a b)) (I.v c);
U.logand_lemma_1 #(I.bits t) (I.v c);
U.logand_lemma_2 #(I.bits t) (I.v c);
() | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_mul | val lemma_mul (f:G.field) (a b:G.felem f) : Lemma
(requires True)
(ensures to_poly (G.fmul a b) == (to_poly a *. to_poly b) %. (irred_poly f))
[SMTPat (to_poly (G.fmul a b))] | val lemma_mul (f:G.field) (a b:G.felem f) : Lemma
(requires True)
(ensures to_poly (G.fmul a b) == (to_poly a *. to_poly b) %. (irred_poly f))
[SMTPat (to_poly (G.fmul a b))] | let lemma_mul f a b =
let G.GF t irred = f in
let n = I.bits t in
let pa = to_poly a in
let pb = to_poly b in
let m = irred_poly f in
lemma_mul_commute pa pb;
lemma_mul_def pb pa;
lemma_mul_pmul pb pa;
lemma_mmul_pmul pa pb m n;
lemma_mmul_smul pa pb m n;
lemma_smul_fmul f a b;
lemma_fmul_gmul f... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 591,
"start_col": 0,
"start_line": 576
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> a: Spec.GaloisField.felem f -> b: Spec.GaloisField.felem f
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.to_poly (Spec.GaloisField.fmul a b) ==
Vale.Math.Poly2.Galois.to_poly a *. Vale.Math.Poly2.Galois.to_poly b %.
Vale.Math.Poly2.Galois.irred_po... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.op_disEquality",
"Lib.IntTypes.U1",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.unit",
"Vale.Math.Poly2.Lemmas.lemma_mod_small",
"Vale.Math.Poly2.Galo... | [] | false | false | true | false | false | let lemma_mul f a b =
| let G.GF t irred = f in
let n = I.bits t in
let pa = to_poly a in
let pb = to_poly b in
let m = irred_poly f in
lemma_mul_commute pa pb;
lemma_mul_def pb pa;
lemma_mul_pmul pb pa;
lemma_mmul_pmul pa pb m n;
lemma_mmul_smul pa pb m n;
lemma_smul_fmul f a b;
lemma_fmul_gmul f a b;
lemma_fmul_fmul f a b;
PL.lemma_mod_smal... | false |
Vale.Curve25519.FastMul_helpers.fst | Vale.Curve25519.FastMul_helpers.lemma_sqr | val lemma_sqr (a:int) (a0 a1 a2 a3
r8 r9 r10 r11 r12 r13 rax rcx
r8' r9' r10' r11' r12' r13' r14'
d0 d1 d2 d3 d4 d5 d6 d7:nat64) (cf:bit)
: Lemma
(requires
a = pow2_four a0 a1 a2 a3 /\
pow2_six r8 r9 r10 r11 r12 r13 ==
pow2_five (mul_nats a0 a1)
... | val lemma_sqr (a:int) (a0 a1 a2 a3
r8 r9 r10 r11 r12 r13 rax rcx
r8' r9' r10' r11' r12' r13' r14'
d0 d1 d2 d3 d4 d5 d6 d7:nat64) (cf:bit)
: Lemma
(requires
a = pow2_four a0 a1 a2 a3 /\
pow2_six r8 r9 r10 r11 r12 r13 ==
pow2_five (mul_nats a0 a1)
... | let lemma_sqr a a0 a1 a2 a3
r8 r9 r10 r11 r12 r13 rax rcx
r8' r9' r10' r11' r12' r13' r14'
d0 d1 d2 d3 d4 d5 d6 d7
cf =
assert (a < pow2_256); // PASSES
assert_norm (pow2_256 == pow2 256); // PASSES
pow2_plus 256 256;
lemma_mul_pow2_bound 256 a a;
... | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastMul_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 410,
"start_col": 0,
"start_line": 304
} | module Vale.Curve25519.FastMul_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
open FStar.Math.Lemmas
#reset-options "--using_facts_from '* -FStar.Tactics -FStar.Reflectio... | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiri... | [
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Prims.int ->
a0: Vale.Def.Types_s.nat64 ->
a1: Vale.Def.Types_s.nat64 ->
a2: Vale.Def.Types_s.nat64 ->
a3: Vale.Def.Types_s.nat64 ->
r8: Vale.Def.Types_s.nat64 ->
r9: Vale.Def.Types_s.nat64 ->
r10: Vale.Def.Types_s.nat64 ->
r11: Vale.Def.Types_s.nat64 ->
r12: Vale.Def.Types_s... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.Curve25519.FastMul_helpers.bit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"Vale.Curve25519.Fast_defs.pow2_nine",
"Vale.Curve25519.FastMul_helpers.int_canon",
"Prims.unit",
"Vale.Curve25519.Fast_defs.pow2_eight",
"Prims._assert",
"FStar.Mu... | [] | false | false | true | false | false | let lemma_sqr
a
a0
a1
a2
a3
r8
r9
r10
r11
r12
r13
rax
rcx
r8'
r9'
r10'
r11'
r12'
r13'
r14'
d0
d1
d2
d3
d4
d5
d6
d7
cf
=
| assert (a < pow2_256);
assert_norm (pow2_256 == pow2 256);
pow2_plus 256 256;
lemma_mul_pow2_bound 256 a a;
assert (a * a < pow2_256 * pow2_256);
assert (cf = 1 ==> pow2_nine d0 d1 d2 d3 d4 d5 d6 d7 cf >= pow2_512);
assert_by_tactic ((pow2_four a0 a1 a2 a3) * (pow2_four a0 a1 a2 a3) ==
pow2_seven (mul_nats a0 a0)
... | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_fmul_gmul | val lemma_fmul_gmul (f: G.field) (a b: G.felem f) : Lemma (fmul f a b == gmul f a b) | val lemma_fmul_gmul (f: G.field) (a b: G.felem f) : Lemma (fmul f a b == gmul f a b) | let lemma_fmul_gmul (f:G.field) (a b:G.felem f) : Lemma
(fmul f a b == gmul f a b)
=
let pred (n:nat) (pab:(fmul_t f)) : Type0 = gmul_rec f a b n == pab in
let _ = Lib.LoopCombinators.repeati_inductive' (I.bits f.G.t - 1) pred (fmul_iter f) (G.zero #f, a, b) in
() | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 543,
"start_col": 0,
"start_line": 538
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> a: Spec.GaloisField.felem f -> b: Spec.GaloisField.felem f
-> FStar.Pervasives.Lemma
(ensures Vale.Math.Poly2.Galois.fmul f a b == Vale.Math.Poly2.Galois.gmul f a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Vale.Math.Poly2.Galois.fmul_t",
"Lib.LoopCombinators.repeati_inductive'",
"Prims.op_Subtraction",
"Lib.IntTypes.bits",
"Spec.GaloisField.__proj__GF__item__t",
"Vale.Math.Poly2.Galois.fmul_iter",
"FStar.Pervasives.Native.Mktuple3",
"Spec.GaloisFi... | [] | false | false | true | false | false | let lemma_fmul_gmul (f: G.field) (a b: G.felem f) : Lemma (fmul f a b == gmul f a b) =
| let pred (n: nat) (pab: (fmul_t f)) : Type0 = gmul_rec f a b n == pab in
let _ =
Lib.LoopCombinators.repeati_inductive' (I.bits f.G.t - 1) pred (fmul_iter f) (G.zero #f, a, b)
in
() | false |
GTWP.fst | GTWP.m | val m (a: Type u#aa) (i: idx) (w: wp a) : Type u#aa | val m (a: Type u#aa) (i: idx) (w: wp a) : Type u#aa | let m (a:Type u#aa) (i:idx) (w : wp a) : Type u#aa =
match i with
| T -> unit -> PURE a w
| G -> unit -> GHOST a w
| D -> raise_t (unit -> DIV a w) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 28,
"start_col": 0,
"start_line": 24
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> i: GTWP.idx -> w: GTWP.wp a -> Type | Prims.Tot | [
"total"
] | [] | [
"GTWP.idx",
"GTWP.wp",
"Prims.unit",
"FStar.Universe.raise_t"
] | [] | false | false | false | true | true | let m (a: Type u#aa) (i: idx) (w: wp a) : Type u#aa =
| match i with
| T -> unit -> PURE a w
| G -> unit -> GHOST a w
| D -> raise_t (unit -> DIV a w) | false |
GTWP.fst | GTWP.bind_wp | val bind_wp (#a #b: _) (wc: wp a) (wf: (a -> wp b)) : wp b | val bind_wp (#a #b: _) (wc: wp a) (wf: (a -> wp b)) : wp b | let bind_wp #a #b (wc : wp a) (wf : a -> wp b) : wp b =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wc (fun x -> wf x p)) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 22,
"start_col": 0,
"start_line": 20
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | wc: GTWP.wp a -> wf: (_: a -> GTWP.wp b) -> GTWP.wp b | Prims.Tot | [
"total"
] | [] | [
"GTWP.wp",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.l_True",
"Prims.pure_pre",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall"
] | [] | false | false | false | true | false | let bind_wp #a #b (wc: wp a) (wf: (a -> wp b)) : wp b =
| elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wc (fun x -> wf x p)) | false |
GTWP.fst | GTWP.return | val return (a: Type) (x: a) (i: idx) : m a i (return_wp x) | val return (a: Type) (x: a) (i: idx) : m a i (return_wp x) | let return (a:Type) (x:a) (i:idx) : m a i (return_wp x) =
match i with
| T -> t_return x
| G -> g_return x
| D -> coerce (d_return x) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 41,
"start_col": 0,
"start_line": 37
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> x: a -> i: GTWP.idx -> GTWP.m a i (GTWP.return_wp x) | Prims.Tot | [
"total"
] | [] | [
"GTWP.idx",
"GTWP.t_return",
"GTWP.g_return",
"GTWP.coerce",
"GTWP.m",
"GTWP.D",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre",
"GTWP.return_wp",
"GTWP.d_return"
] | [] | false | false | false | false | false | let return (a: Type) (x: a) (i: idx) : m a i (return_wp x) =
| match i with
| T -> t_return x
| G -> g_return x
| D -> coerce (d_return x) | false |
GTWP.fst | GTWP.g_return | val g_return (#a: _) (x: a) : m a G (as_pure_wp (fun p -> p x)) | val g_return (#a: _) (x: a) : m a G (as_pure_wp (fun p -> p x)) | let g_return #a (x:a) : m a G (as_pure_wp (fun p -> p x)) = (fun () -> x) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 31,
"start_col": 0,
"start_line": 31
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> GTWP.m a GTWP.G (FStar.Monotonic.Pure.as_pure_wp (fun p -> p x)) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"GTWP.m",
"GTWP.G",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre"
] | [] | false | false | false | false | false | let g_return #a (x: a) : m a G (as_pure_wp (fun p -> p x)) =
| (fun () -> x) | false |
Steel.Reference.fsti | Steel.Reference.ghost_gather | val ghost_gather (#a: Type0) (#uses: _) (#p: perm) (r: ghost_ref a)
: SteelGhost unit
uses
((ghost_vptrp r (half_perm p)) `star` (ghost_vptrp r (half_perm p)))
(fun _ -> ghost_vptrp r p)
(fun _ -> True)
(fun h _ h' -> h' (ghost_vptrp r p) == h (ghost_vptrp r (half_perm p))) | val ghost_gather (#a: Type0) (#uses: _) (#p: perm) (r: ghost_ref a)
: SteelGhost unit
uses
((ghost_vptrp r (half_perm p)) `star` (ghost_vptrp r (half_perm p)))
(fun _ -> ghost_vptrp r p)
(fun _ -> True)
(fun h _ h' -> h' (ghost_vptrp r p) == h (ghost_vptrp r (half_perm p))) | let ghost_gather (#a: Type0) (#uses: _) (#p: perm) (r: ghost_ref a)
: SteelGhost unit uses
(ghost_vptrp r (half_perm p) `star` ghost_vptrp r (half_perm p))
(fun _ -> ghost_vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (ghost_vptrp r p) == h (ghost_vptrp r (half_perm p))
)
= let _ ... | {
"file_name": "lib/steel/Steel.Reference.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 21,
"end_line": 561,
"start_col": 0,
"start_line": 550
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.check... | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ste... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Steel.Reference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.Reference.ghost_ref",
"Steel.Effect.Atomic.change_equal_slprop",
"Steel.Reference.ghost_vptrp",
"Prims.unit",
"Steel.Reference.ghost_gather_gen",
"Steel.FractionalPermission.half_perm",
"Steel.Effect.Common.star",
"Steel.Effect.Commo... | [] | false | true | false | false | false | let ghost_gather (#a: Type0) (#uses: _) (#p: perm) (r: ghost_ref a)
: SteelGhost unit
uses
((ghost_vptrp r (half_perm p)) `star` (ghost_vptrp r (half_perm p)))
(fun _ -> ghost_vptrp r p)
(fun _ -> True)
(fun h _ h' -> h' (ghost_vptrp r p) == h (ghost_vptrp r (half_perm p))) =
| let _ = ghost_gather_gen r _ _ in
change_equal_slprop (ghost_vptrp r _) (ghost_vptrp r p) | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_smul_fmul | val lemma_smul_fmul (f: G.field) (e1 e2: G.felem f)
: Lemma (to_poly (gmul f e1 e2) == smul (to_poly e1) (to_poly e2) (irred_poly f) (I.bits f.G.t)) | val lemma_smul_fmul (f: G.field) (e1 e2: G.felem f)
: Lemma (to_poly (gmul f e1 e2) == smul (to_poly e1) (to_poly e2) (irred_poly f) (I.bits f.G.t)) | let lemma_smul_fmul (f:G.field) (e1 e2:G.felem f) : Lemma
(to_poly (gmul f e1 e2) == smul (to_poly e1) (to_poly e2) (irred_poly f) (I.bits f.G.t))
=
let G.GF t irred = f in
let n = I.bits t in
lemma_smul_gmul_rec f e1 e2 n | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 536,
"start_col": 0,
"start_line": 531
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> e1: Spec.GaloisField.felem f -> e2: Spec.GaloisField.felem f
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Galois.to_poly (Vale.Math.Poly2.Galois.gmul f e1 e2) ==
Vale.Math.Poly2.Galois.smul (Vale.Math.Poly2.Galois.to_poly e1)
(Vale.Math.Poly2.Galois.to_poly e... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.op_disEquality",
"Lib.IntTypes.U1",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Vale.Math.Poly2.Galois.lemma_smul_gmul_rec",
"Prims.int",
"Lib.IntTypes.bits... | [] | false | false | true | false | false | let lemma_smul_fmul (f: G.field) (e1 e2: G.felem f)
: Lemma (to_poly (gmul f e1 e2) == smul (to_poly e1) (to_poly e2) (irred_poly f) (I.bits f.G.t)) =
| let G.GF t irred = f in
let n = I.bits t in
lemma_smul_gmul_rec f e1 e2 n | false |
GTWP.fst | GTWP.t_return | val t_return (#a: _) (x: a) : m a T (as_pure_wp (fun p -> p x)) | val t_return (#a: _) (x: a) : m a T (as_pure_wp (fun p -> p x)) | let t_return #a (x:a) : m a T (as_pure_wp (fun p -> p x)) = (fun () -> x) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 30,
"start_col": 0,
"start_line": 30
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> GTWP.m a GTWP.T (FStar.Monotonic.Pure.as_pure_wp (fun p -> p x)) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"GTWP.m",
"GTWP.T",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre"
] | [] | false | false | false | false | false | let t_return #a (x: a) : m a T (as_pure_wp (fun p -> p x)) =
| (fun () -> x) | false |
GTWP.fst | GTWP.g_bind | val g_bind (#a #b #wc #wf: _) (c: m a G wc) (f: (x: a -> m b G (wf x))) : m b G (bind_wp wc wf) | val g_bind (#a #b #wc #wf: _) (c: m a G wc) (f: (x: a -> m b G (wf x))) : m b G (bind_wp wc wf) | let g_bind #a #b #wc #wf (c : m a G wc) (f : (x:a -> m b G (wf x))) : m b G (bind_wp wc wf) = elim_pure_wp_monotonicity_forall (); fun () -> f (c ()) () | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 152,
"end_line": 45,
"start_col": 0,
"start_line": 45
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: GTWP.m a GTWP.G wc -> f: (x: a -> GTWP.m b GTWP.G (wf x)) -> GTWP.m b GTWP.G (GTWP.bind_wp wc wf) | Prims.Tot | [
"total"
] | [] | [
"GTWP.wp",
"GTWP.m",
"GTWP.G",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall",
"GTWP.bind_wp"
] | [] | false | false | false | false | false | let g_bind #a #b #wc #wf (c: m a G wc) (f: (x: a -> m b G (wf x))) : m b G (bind_wp wc wf) =
| elim_pure_wp_monotonicity_forall ();
fun () -> f (c ()) () | false |
Lib.ByteSequence.fst | Lib.ByteSequence.lemma_uints_to_bytes_le_sub | val lemma_uints_to_bytes_le_sub :
#t : inttype{unsigned t /\ ~(U1? t)} ->
#l : secrecy_level ->
#len:size_nat{len * numbytes t < pow2 32} ->
s : lseq (uint_t t l) len ->
i : size_nat {i < len} ->
Lemma(sub (uints_to_bytes_le #t #l s) (i * numbytes t) (numbytes t) == uint_to_bytes_le (index s i)) | val lemma_uints_to_bytes_le_sub :
#t : inttype{unsigned t /\ ~(U1? t)} ->
#l : secrecy_level ->
#len:size_nat{len * numbytes t < pow2 32} ->
s : lseq (uint_t t l) len ->
i : size_nat {i < len} ->
Lemma(sub (uints_to_bytes_le #t #l s) (i * numbytes t) (numbytes t) == uint_to_bytes_le (index s i)) | let lemma_uints_to_bytes_le_sub #t #l #len s i =
let lemma_uints_to_bytes_le_i_j (j : size_nat {j < numbytes t}):
Lemma(index (uints_to_bytes_le #t #l s) (i * numbytes t + j) == index (uint_to_bytes_le (index s i)) j) =
index_uints_to_bytes_le #t #l #len s (i*numbytes t + j);
assert (index (uint... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 105,
"end_line": 846,
"start_col": 0,
"start_line": 838
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Lib.Sequence.lseq (Lib.IntTypes.uint_t t l) len -> i: Lib.IntTypes.size_nat{i < len}
-> FStar.Pervasives.Lemma
(ensures
Lib.Sequence.sub (Lib.ByteSequence.uints_to_bytes_le s)
(i * Lib.IntTypes.numbytes t)
(Lib.IntTypes.numbytes t) ==
Lib.ByteSequence.uint_to_bytes_le (Lib.Sequence.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.l_not",
"Lib.IntTypes.uu___is_U1",
"Lib.IntTypes.secrecy_level",
"Lib.IntTypes.size_nat",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Prims.pow2",
"Lib.Sequence.lseq",
"Lib.IntTypes.... | [] | false | false | true | false | false | let lemma_uints_to_bytes_le_sub #t #l #len s i =
| let lemma_uints_to_bytes_le_i_j (j: size_nat{j < numbytes t})
: Lemma
(index (uints_to_bytes_le #t #l s) (i * numbytes t + j) ==
index (uint_to_bytes_le (index s i)) j) =
index_uints_to_bytes_le #t #l #len s (i * numbytes t + j);
assert (index (uints_to_bytes_le #t #l s) (i * numbytes t + j) ==
... | false |
GTWP.fst | GTWP.return_wp | val return_wp (#a: _) (x: a) : wp a | val return_wp (#a: _) (x: a) : wp a | let return_wp #a (x:a) : wp a =
as_pure_wp (fun p -> p x) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 35,
"start_col": 0,
"start_line": 34
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> GTWP.wp a | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre",
"GTWP.wp"
] | [] | false | false | false | true | false | let return_wp #a (x: a) : wp a =
| as_pure_wp (fun p -> p x) | false |
Lib.ByteSequence.fst | Lib.ByteSequence.index_nat_to_intseq_to_bytes_be | val index_nat_to_intseq_to_bytes_be:
#t:inttype{unsigned t /\ ~(U1? t)}
-> #l:secrecy_level
-> len:nat{len * numbytes t < pow2 32}
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len * numbytes t}
-> Lemma (let s:lseq (int_t t l) len = nat_to_intseq_be #t #l len n in
Seq.index (nat_to_bytes_be #... | val index_nat_to_intseq_to_bytes_be:
#t:inttype{unsigned t /\ ~(U1? t)}
-> #l:secrecy_level
-> len:nat{len * numbytes t < pow2 32}
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len * numbytes t}
-> Lemma (let s:lseq (int_t t l) len = nat_to_intseq_be #t #l len n in
Seq.index (nat_to_bytes_be #... | let index_nat_to_intseq_to_bytes_be #t #l len n i =
let s:lseq (uint_t t l) len = nat_to_intseq_be #t #l len n in
let m = numbytes t in
calc (==) {
Seq.index (nat_to_bytes_be #l m (v s.[len - 1 - i / m])) (m - (i % m) - 1);
== { index_nat_to_intseq_be #U8 #l m (v s.[len - 1 - i / m]) (i % m) }
uint (v... | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 695,
"start_col": 0,
"start_line": 682
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Prims.nat{len * Lib.IntTypes.numbytes t < Prims.pow2 32} ->
n: Prims.nat{n < Prims.pow2 (Lib.IntTypes.bits t * len)} ->
i: Prims.nat{i < len * Lib.IntTypes.numbytes t}
-> FStar.Pervasives.Lemma
(ensures
(let s = Lib.ByteSequence.nat_to_intseq_be len n in
FStar.Seq.Base.index (Lib.B... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.l_not",
"Lib.IntTypes.uu___is_U1",
"Lib.IntTypes.secrecy_level",
"Prims.nat",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Prims.pow2",
"Lib.IntTypes.bits",
"FStar.Calc.calc_finish",
... | [] | false | false | true | false | false | let index_nat_to_intseq_to_bytes_be #t #l len n i =
| let s:lseq (uint_t t l) len = nat_to_intseq_be #t #l len n in
let m = numbytes t in
calc ( == ) {
Seq.index (nat_to_bytes_be #l m (v s.[ len - 1 - i / m ])) (m - (i % m) - 1);
( == ) { index_nat_to_intseq_be #U8 #l m (v s.[ len - 1 - i / m ]) (i % m) }
uint (v s.[ len - 1 - i / m ] / pow2 (8 * (i % m)) % pow2 8);... | false |
GTWP.fst | GTWP.t_bind | val t_bind (#a #b #wc #wf: _) (c: m a T wc) (f: (x: a -> m b T (wf x))) : m b T (bind_wp wc wf) | val t_bind (#a #b #wc #wf: _) (c: m a T wc) (f: (x: a -> m b T (wf x))) : m b T (bind_wp wc wf) | let t_bind #a #b #wc #wf (c : m a T wc) (f : (x:a -> m b T (wf x))) : m b T (bind_wp wc wf) = elim_pure_wp_monotonicity_forall (); fun () -> f (c ()) () | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 152,
"end_line": 44,
"start_col": 0,
"start_line": 44
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: GTWP.m a GTWP.T wc -> f: (x: a -> GTWP.m b GTWP.T (wf x)) -> GTWP.m b GTWP.T (GTWP.bind_wp wc wf) | Prims.Tot | [
"total"
] | [] | [
"GTWP.wp",
"GTWP.m",
"GTWP.T",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall",
"GTWP.bind_wp"
] | [] | false | false | false | false | false | let t_bind #a #b #wc #wf (c: m a T wc) (f: (x: a -> m b T (wf x))) : m b T (bind_wp wc wf) =
| elim_pure_wp_monotonicity_forall ();
fun () -> f (c ()) () | false |
GTWP.fst | GTWP.bind | val bind (a b: Type) (i: idx) (wc: wp a) (wf: (a -> wp b)) (c: m a i wc) (f: (x: a -> m b i (wf x)))
: m b i (bind_wp wc wf) | val bind (a b: Type) (i: idx) (wc: wp a) (wf: (a -> wp b)) (c: m a i wc) (f: (x: a -> m b i (wf x)))
: m b i (bind_wp wc wf) | let bind (a b : Type) (i:idx) (wc:wp a) (wf:a -> wp b) (c : m a i wc) (f : (x:a -> m b i (wf x))) : m b i (bind_wp wc wf) =
elim_pure_wp_monotonicity_forall ();
match i with
| T -> t_bind #_ #_ #wc #wf c f
| G -> g_bind #_ #_ #wc #wf c f
| D -> coerce (d_bind #_ #_ #wc #wf (coerce c) f) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 56,
"start_col": 0,
"start_line": 51
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Type ->
b: Type ->
i: GTWP.idx ->
wc: GTWP.wp a ->
wf: (_: a -> GTWP.wp b) ->
c: GTWP.m a i wc ->
f: (x: a -> GTWP.m b i (wf x))
-> GTWP.m b i (GTWP.bind_wp wc wf) | Prims.Tot | [
"total"
] | [] | [
"GTWP.idx",
"GTWP.wp",
"GTWP.m",
"GTWP.t_bind",
"GTWP.g_bind",
"GTWP.coerce",
"GTWP.D",
"GTWP.bind_wp",
"GTWP.d_bind",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall"
] | [] | false | false | false | false | false | let bind (a b: Type) (i: idx) (wc: wp a) (wf: (a -> wp b)) (c: m a i wc) (f: (x: a -> m b i (wf x)))
: m b i (bind_wp wc wf) =
| elim_pure_wp_monotonicity_forall ();
match i with
| T -> t_bind #_ #_ #wc #wf c f
| G -> g_bind #_ #_ #wc #wf c f
| D -> coerce (d_bind #_ #_ #wc #wf (coerce c) f) | false |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.malloc | val malloc: malloc_st (|Blake2S, M32|) | val malloc: malloc_st (|Blake2S, M32|) | let malloc = BlS32.malloc_with_key | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 13,
"start_col": 0,
"start_line": 13
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.malloc_st (| Spec.Hash.Definitions.Blake2S, Hacl.Impl.Blake2.Core.M32 |) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Blake2s_32.malloc_with_key"
] | [] | false | false | false | false | false | let malloc =
| BlS32.malloc_with_key | false |
Lib.ByteSequence.fst | Lib.ByteSequence.uints_from_bytes_be_nat_lemma_aux | val uints_from_bytes_be_nat_lemma_aux:
#t:inttype{unsigned t /\ ~(U1? t)}
-> #l:secrecy_level
-> #len:size_pos{len * numbytes t < pow2 32}
-> b:lbytes_l l (len * numbytes t) ->
Lemma (nat_from_intseq_be_ (uints_from_bytes_be #t #l #len b) ==
nat_from_intseq_be (uints_from_bytes_be #t #l #(len-1) (sl... | val uints_from_bytes_be_nat_lemma_aux:
#t:inttype{unsigned t /\ ~(U1? t)}
-> #l:secrecy_level
-> #len:size_pos{len * numbytes t < pow2 32}
-> b:lbytes_l l (len * numbytes t) ->
Lemma (nat_from_intseq_be_ (uints_from_bytes_be #t #l #len b) ==
nat_from_intseq_be (uints_from_bytes_be #t #l #(len-1) (sl... | let uints_from_bytes_be_nat_lemma_aux #t #l #len b =
let r = uints_from_bytes_be #t #l #len b in
uints_from_bytes_be_slice_lemma #t #l #len b 1 len;
nat_from_intseq_be_slice_lemma r 1;
assert (nat_from_intseq_be_ r == nat_from_intseq_be (slice r 1 len) + pow2 ((len - 1) * bits t) * uint_v r.[0]) | {
"file_name": "lib/Lib.ByteSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 113,
"end_line": 532,
"start_col": 0,
"start_line": 528
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#reset-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
/// BEGIN constant-time sequence equality
val lemma_not_equal_slice: #a:Type -> b1:Seq.seq a -> b2:Seq.seq a -> i:nat -> j:nat ->
k:n... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: Lib.ByteSequence.lbytes_l l (len * Lib.IntTypes.numbytes t)
-> FStar.Pervasives.Lemma
(ensures
Lib.ByteSequence.nat_from_intseq_be_ (Lib.ByteSequence.uints_from_bytes_be b) ==
Lib.ByteSequence.nat_from_intseq_be (Lib.ByteSequence.uints_from_bytes_be (Lib.Sequence.slice b
(Lib.IntTyp... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.l_not",
"Lib.IntTypes.uu___is_U1",
"Lib.IntTypes.secrecy_level",
"Lib.IntTypes.size_pos",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Prims.pow2",
"Lib.ByteSequence.lbytes_l",
"Prims... | [] | true | false | true | false | false | let uints_from_bytes_be_nat_lemma_aux #t #l #len b =
| let r = uints_from_bytes_be #t #l #len b in
uints_from_bytes_be_slice_lemma #t #l #len b 1 len;
nat_from_intseq_be_slice_lemma r 1;
assert (nat_from_intseq_be_ r ==
nat_from_intseq_be (slice r 1 len) + pow2 ((len - 1) * bits t) * uint_v r.[ 0 ]) | false |
GTWP.fst | GTWP.d_return | val d_return (#a: _) (x: a) : m a D (as_pure_wp (fun p -> p x)) | val d_return (#a: _) (x: a) : m a D (as_pure_wp (fun p -> p x)) | let d_return #a (x:a) : m a D (as_pure_wp (fun p -> p x)) = raise_val (fun () -> x) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 83,
"end_line": 32,
"start_col": 0,
"start_line": 32
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> GTWP.m a GTWP.D (FStar.Monotonic.Pure.as_pure_wp (fun p -> p x)) | Prims.Tot | [
"total"
] | [] | [
"FStar.Universe.raise_val",
"Prims.unit",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre",
"GTWP.m",
"GTWP.D"
] | [] | false | false | false | false | false | let d_return #a (x: a) : m a D (as_pure_wp (fun p -> p x)) =
| raise_val (fun () -> x) | false |
GTWP.fst | GTWP.subcomp | val subcomp (a: Type u#aa) (i: idx) (wp1 wp2: wp a) (f: m a i wp1)
: Pure (m a i wp2) (requires (forall p. wp2 p ==> wp1 p)) (ensures (fun _ -> True)) | val subcomp (a: Type u#aa) (i: idx) (wp1 wp2: wp a) (f: m a i wp1)
: Pure (m a i wp2) (requires (forall p. wp2 p ==> wp1 p)) (ensures (fun _ -> True)) | let subcomp (a:Type u#aa) (i:idx)
(wp1 : wp a)
(wp2 : wp a)
(f : m a i wp1)
: Pure (m a i wp2)
(requires (forall p. wp2 p ==> wp1 p))
(ensures (fun _ -> True))
= match i with
| T -> f
| G -> f
| D ->
(* This case needs some handholding.... | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 75,
"start_col": 0,
"start_line": 59
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> i: GTWP.idx -> wp1: GTWP.wp a -> wp2: GTWP.wp a -> f: GTWP.m a i wp1
-> Prims.Pure (GTWP.m a i wp2) | Prims.Pure | [] | [] | [
"GTWP.idx",
"GTWP.wp",
"GTWP.m",
"GTWP.coerce",
"FStar.Universe.raise_t",
"Prims.unit",
"FStar.Universe.raise_val",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"FStar.Universe.downgrade_val",
"Prims.l_Forall",
"Prims.pure_post",
"Prims.l_imp",
"Prims.l_True"
] | [] | false | false | false | false | false | let subcomp (a: Type u#aa) (i: idx) (wp1 wp2: wp a) (f: m a i wp1)
: Pure (m a i wp2) (requires (forall p. wp2 p ==> wp1 p)) (ensures (fun _ -> True)) =
| match i with
| T -> f
| G -> f
| D ->
let f:raise_t (unit -> DIV a wp1) = f in
let f: unit -> DIV a wp1 = downgrade_val f in
let f: unit -> DIV a wp2 = f in
assert_norm (m a i wp2 == raise_t (unit -> DIV a wp2));
coerce (raise_val f) | false |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.init | val init: init_st (|Blake2S, M32|) | val init: init_st (|Blake2S, M32|) | let init s = BlS32.init s 0ul 32ul | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 24,
"start_col": 0,
"start_line": 24
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash
let malloc = BlS32.malloc_with_key
let alloca () =
let h0 = ST.get() in
let s = Hacl.Imp... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.init_st (| Spec.Hash.Definitions.Blake2S, Hacl.Impl.Blake2.Core.M32 |) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Blake2s_32.init",
"FStar.UInt32.__uint_to_t",
"Prims.unit"
] | [] | false | false | false | false | false | let init s =
| BlS32.init s 0ul 32ul | false |
GTWP.fst | GTWP.ite_wp | val ite_wp (#a: _) (w1 w2: wp a) (b: bool) : wp a | val ite_wp (#a: _) (w1 w2: wp a) (b: bool) : wp a | let ite_wp #a (w1 w2 : wp a) (b:bool) : wp a =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> if b then w1 p else w2 p) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 80,
"start_col": 0,
"start_line": 78
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | w1: GTWP.wp a -> w2: GTWP.wp a -> b: Prims.bool -> GTWP.wp a | Prims.Tot | [
"total"
] | [] | [
"GTWP.wp",
"Prims.bool",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall"
] | [] | false | false | false | true | false | let ite_wp #a (w1: wp a) (w2: wp a) (b: bool) : wp a =
| elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> if b then w1 p else w2 p) | false |
GTWP.fst | GTWP.map | val map (#a #b #i: _) (f: (a -> Gtd b i)) (xs: list a) : Gtd (list b) i | val map (#a #b #i: _) (f: (a -> Gtd b i)) (xs: list a) : Gtd (list b) i | let rec map #a #b #i (f : a -> Gtd b i) (xs : list a) : Gtd (list b) i (* by (explode (); dump "") *) =
match xs with
| [] -> []
| x::xs -> (f x)::(map f xs) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 135,
"start_col": 0,
"start_line": 132
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> GTWP.Gtd b) -> xs: Prims.list a -> GTWP.Gtd (Prims.list b) | GTWP.Gtd | [] | [] | [
"GTWP.idx",
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"GTWP.map"
] | [
"recursion"
] | false | true | false | false | false | let rec map #a #b #i (f: (a -> Gtd b i)) (xs: list a) : Gtd (list b) i =
| match xs with
| [] -> []
| x :: xs -> (f x) :: (map f xs) | false |
GTWP.fst | GTWP.null_wp | val null_wp (a: Type) : pure_wp a | val null_wp (a: Type) : pure_wp a | let null_wp (a:Type) : pure_wp a = as_pure_wp (fun p -> forall x. p x) | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 128,
"start_col": 0,
"start_line": 128
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> Prims.pure_wp a | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.l_Forall",
"Prims.l_True",
"Prims.pure_pre",
"Prims.pure_wp"
] | [] | false | false | false | true | false | let null_wp (a: Type) : pure_wp a =
| as_pure_wp (fun p -> forall x. p x) | false |
GTWP.fst | GTWP.lift_pure_gtd | val lift_pure_gtd (a: Type) (w: wp a) (i: idx) (f: (unit -> PURE a w))
: Pure (m a i w) (requires True) (ensures (fun _ -> True)) | val lift_pure_gtd (a: Type) (w: wp a) (i: idx) (f: (unit -> PURE a w))
: Pure (m a i w) (requires True) (ensures (fun _ -> True)) | let lift_pure_gtd (a:Type) (w : wp a) (i : idx)
(f : unit -> PURE a w)
: Pure (m a i w)
(requires True)
(ensures (fun _ -> True))
= elim_pure_wp_monotonicity_forall ();
match i with
| T -> f
| G -> f
| D -> let f' () : DIV a... | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 113,
"start_col": 0,
"start_line": 102
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> w: GTWP.wp a -> i: GTWP.idx -> f: (_: Prims.unit -> Prims.PURE a)
-> Prims.Pure (GTWP.m a i w) | Prims.Pure | [] | [] | [
"GTWP.wp",
"GTWP.idx",
"Prims.unit",
"GTWP.m",
"GTWP.D",
"FStar.Universe.raise_val",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall",
"Prims.l_True"
] | [] | false | false | false | false | false | let lift_pure_gtd (a: Type) (w: wp a) (i: idx) (f: (unit -> PURE a w))
: Pure (m a i w) (requires True) (ensures (fun _ -> True)) =
| elim_pure_wp_monotonicity_forall ();
match i with
| T -> f
| G -> f
| D ->
let f' () : DIV a w = f () in
let f'':m a D w = raise_val f' in
f'' | false |
GTWP.fst | GTWP.labs | val labs (#i: _) (n: int) : Gtd nat i | val labs (#i: _) (n: int) : Gtd nat i | let labs #i (n:int) : Gtd nat i =
if n < 0
then -n
else n | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 162,
"start_col": 0,
"start_line": 159
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.int -> GTWP.Gtd Prims.nat | GTWP.Gtd | [] | [] | [
"GTWP.idx",
"Prims.int",
"Prims.op_LessThan",
"Prims.op_Minus",
"Prims.bool",
"Prims.nat"
] | [] | false | true | false | false | false | let labs #i (n: int) : Gtd nat i =
| if n < 0 then - n else n | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_fmul_fmul | val lemma_fmul_fmul (f: G.field) (a b: G.felem f) : Lemma (G.fmul a b == fmul f a b) | val lemma_fmul_fmul (f: G.field) (a b: G.felem f) : Lemma (G.fmul a b == fmul f a b) | let lemma_fmul_fmul (f:G.field) (a b:G.felem f) : Lemma
(G.fmul a b == fmul f a b)
=
let repeati = Lib.LoopCombinators.repeati in
let acc0 = (G.zero #f, a, b) in
let rec lem (n:nat{n < I.bits f.G.t}) (f1:(i:nat{i < n} -> fmul_t f -> fmul_t f)) : Lemma
(requires (forall (i:nat{i < n}) (pab:fmul_t f). f1 i ... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 573,
"start_col": 0,
"start_line": 547
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> a: Spec.GaloisField.felem f -> b: Spec.GaloisField.felem f
-> FStar.Pervasives.Lemma (ensures Spec.GaloisField.fmul a b == Vale.Math.Poly2.Galois.fmul f a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"Spec.GaloisField.__proj__GF__item__t",
"Vale.Math.Poly2.Galois.fmul_t",
"Prims.unit",
"Prims.l_Forall",
"Prims.eq2",
"Vale.Math.Poly2.Galois.fmul_iter",
"Prims.squash",
... | [] | false | false | true | false | false | let lemma_fmul_fmul (f: G.field) (a b: G.felem f) : Lemma (G.fmul a b == fmul f a b) =
| let repeati = Lib.LoopCombinators.repeati in
let acc0 = (G.zero #f, a, b) in
let rec lem (n: nat{n < I.bits f.G.t}) (f1: (i: nat{i < n} -> fmul_t f -> fmul_t f))
: Lemma (requires (forall (i: nat{i < n}) (pab: fmul_t f). f1 i pab == fmul_iter f i pab))
(ensures repeati n (fmul_iter f) acc0 == repeati n f1 acc... | false |
GTWP.fst | GTWP.appn | val appn (#a #i: _) (n: nat) (f: (a -> Gtd a i)) (x: a) : Gtd a i | val appn (#a #i: _) (n: nat) (f: (a -> Gtd a i)) (x: a) : Gtd a i | let rec appn #a #i (n:nat) (f : a -> Gtd a i) (x : a) : Gtd a i =
match n with
| 0 -> x
| _ -> begin
appn (n-1) f (f x)
end | {
"file_name": "examples/layeredeffects/GTWP.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 146,
"start_col": 0,
"start_line": 141
} | module GTWP
open FStar.Tactics.V2
open FStar.Universe
open FStar.Monotonic.Pure
type idx =
| T
| G
| D
// GM: Force a type equality by SMT
let coerce #a #b (x:a{a == b}) : b = x
// GM: Warning: the [unfold]s here are important.
let wp (a:Type) = pure_wp a
unfold
let bind_wp #a #b (wc : wp a) (wf : a -> wp b) :... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "GTWP.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat -> f: (_: a -> GTWP.Gtd a) -> x: a -> GTWP.Gtd a | GTWP.Gtd | [] | [] | [
"GTWP.idx",
"Prims.nat",
"Prims.int",
"GTWP.appn",
"Prims.op_Subtraction"
] | [
"recursion"
] | false | true | false | false | false | let rec appn #a #i (n: nat) (f: (a -> Gtd a i)) (x: a) : Gtd a i =
| match n with
| 0 -> x
| _ -> appn (n - 1) f (f x) | false |
LowStar.Endianness.fst | LowStar.Endianness.store_post | val store_post : b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i: Prims.nat ->
j: Prims.nat{i + j <= LowStar.Monotonic.Buffer.length b} ->
predicate: (_: FStar.Seq.Base.seq a -> Type0) ->
h0: FStar.Monotonic.HyperStack.mem ->
_: Prims.unit ->
h1: FStar.Monotonic.HyperStack.mem
-> Prims.GTo... | let store_post
(#a:Type) (#rrel #rel:MB.srel a) (b:MB.mbuffer a rrel rel)
(i:nat) (j:nat{i + j <= MB.length b}) (predicate:Seq.seq a -> Type0)
= fun (h0:HS.mem) (_:unit) (h1:HS.mem) ->
MB.live h1 b /\
MB.(modifies (loc_buffer b) h0 h1) /\
(let s1 = MB.as_seq h0 b in
let s2 = MB.as_seq h1 b i... | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 102,
"start_col": 7,
"start_line": 89
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i: Prims.nat ->
j: Prims.nat{i + j <= LowStar.Monotonic.Buffer.length b} ->
predicate: (_: FStar.Seq.Base.seq a -> Type0) ->
h0: FStar.Monotonic.HyperStack.mem ->
_: Prims.unit ->
h1: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logi... | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"LowStar.Monotonic.Buffer.length",
"FStar.Seq.Base.seq",
"FStar.Monotonic.HyperStack.mem",
"Prims.unit",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live... | [] | false | false | false | false | true | let store_post
(#a: Type)
(#rrel #rel: MB.srel a)
(b: MB.mbuffer a rrel rel)
(i: nat)
(j: nat{i + j <= MB.length b})
(predicate: (Seq.seq a -> Type0))
=
| fun (h0: HS.mem) (_: unit) (h1: HS.mem) ->
MB.live h1 b /\ MB.(modifies (loc_buffer b) h0 h1) /\
(let s1 = MB.as_seq h0 b in
let s2 = MB.as_seq h1 b in
let len = MB.length b in
Seq.equal (Seq.slice s2 0 i) (Seq.slice s1 0 i) /\
Seq.equal (Seq.slice s2 (i + j) len) (Seq.slice s1 (i + j) len) /\
p... | false | |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.hash | val hash: hash_st Blake2S | val hash: hash_st Blake2S | let hash output input input_len = Hacl.Streaming.Blake2s_32.hash_with_key output 32ul input input_len (null #MUT uint8) 0ul | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 123,
"end_line": 40,
"start_col": 0,
"start_line": 40
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash
let malloc = BlS32.malloc_with_key
let alloca () =
let h0 = ST.get() in
let s = Hacl.Imp... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.hash_st Spec.Hash.Definitions.Blake2S | Prims.Tot | [
"total"
] | [] | [
"Hacl.Hash.Definitions.hash_t",
"Spec.Hash.Definitions.Blake2S",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"LowStar.Monotonic.Buff... | [] | false | false | false | true | false | let hash output input input_len =
| Hacl.Streaming.Blake2s_32.hash_with_key output 32ul input input_len (null #MUT uint8) 0ul | false |
LowStar.Endianness.fst | LowStar.Endianness.load64_le | val load64_le (b: B.buffer UInt8.t {B.length b == 8})
: Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt64.v z)) | val load64_le (b: B.buffer UInt8.t {B.length b == 8})
: Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt64.v z)) | let load64_le
(b:B.buffer UInt8.t{B.length b == 8}):
Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt64.v z))
=
load64_le_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 357,
"start_col": 0,
"start_line": 350
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 8}
-> FStar.HyperStack.ST.Stack FStar.UInt64.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load64_le_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u64",
"FStar.UInt64.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monoton... | [] | false | true | false | false | false | let load64_le (b: B.buffer UInt8.t {B.length b == 8})
: Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt64.v z)) =
| load64_le_i b 0ul | false |
LowStar.Endianness.fst | LowStar.Endianness.store16_le | val store16_le (b: B.buffer UInt8.t {B.length b == 2}) (z: UInt16.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt16.v z)) | val store16_le (b: B.buffer UInt8.t {B.length b == 2}) (z: UInt16.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt16.v z)) | let store16_le
(b:B.buffer UInt8.t{B.length b == 2})
(z:UInt16.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt16.v z))
=
store16_le_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 268,
"start_col": 0,
"start_line": 260
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 2} -> z: FStar.UInt16.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt16.t",
"LowStar.Endianness.store16_le_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.l... | [] | false | true | false | false | false | let store16_le (b: B.buffer UInt8.t {B.length b == 2}) (z: UInt16.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt16.v z)) =
| store16_le_i b 0ul z | false |
LowStar.Endianness.fst | LowStar.Endianness.load16_be | val load16_be (b: B.buffer UInt8.t {B.length b == 2})
: Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt16.v z)) | val load16_be (b: B.buffer UInt8.t {B.length b == 2})
: Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt16.v z)) | let load16_be
(b:B.buffer UInt8.t{B.length b == 2}):
Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt16.v z))
=
load16_be_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 297,
"start_col": 0,
"start_line": 290
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 2}
-> FStar.HyperStack.ST.Stack FStar.UInt16.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load16_be_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u16",
"FStar.UInt16.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monoton... | [] | false | true | false | false | false | let load16_be (b: B.buffer UInt8.t {B.length b == 2})
: Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt16.v z)) =
| load16_be_i b 0ul | false |
LowStar.Endianness.fst | LowStar.Endianness.store_pre | val store_pre : b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i: Prims.nat ->
j: Prims.nat{i + j <= LowStar.Monotonic.Buffer.length b} ->
predicate: (_: FStar.Seq.Base.seq a -> Type0) ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | let store_pre
(#a:Type) (#rrel #rel:MB.srel a) (b:MB.mbuffer a rrel rel)
(i:nat) (j:nat{i + j <= MB.length b}) (predicate:Seq.seq a -> Type0)
= fun (h:HS.mem) ->
let sb = MB.as_seq h b in
let len = MB.length b in
MB.live h b /\
(forall (s:Seq.seq a). //monotonicity precondition that once the co... | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 84,
"start_col": 7,
"start_line": 66
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i: Prims.nat ->
j: Prims.nat{i + j <= LowStar.Monotonic.Buffer.length b} ->
predicate: (_: FStar.Seq.Base.seq a -> Type0) ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"LowStar.Monotonic.Buffer.length",
"FStar.Seq.Base.seq",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"Prims.l_Fo... | [] | false | false | false | false | true | let store_pre
(#a: Type)
(#rrel #rel: MB.srel a)
(b: MB.mbuffer a rrel rel)
(i: nat)
(j: nat{i + j <= MB.length b})
(predicate: (Seq.seq a -> Type0))
=
| fun (h: HS.mem) ->
let sb = MB.as_seq h b in
let len = MB.length b in
MB.live h b /\
(forall (s: Seq.seq a).
(Seq.length s == len /\ Seq.equal (Seq.slice s 0 i) (Seq.slice sb 0 i) /\
Seq.equal (Seq.slice s (i + j) len) (Seq.slice sb (i + j) len) /\
predicate (Seq.slice s i (i + j))) ==>
... | false | |
LowStar.Endianness.fst | LowStar.Endianness.store32_le | val store32_le (b: B.buffer UInt8.t {B.length b == 4}) (z: UInt32.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt32.v z)) | val store32_le (b: B.buffer UInt8.t {B.length b == 4}) (z: UInt32.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt32.v z)) | let store32_le
(b:B.buffer UInt8.t{B.length b == 4})
(z:UInt32.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt32.v z))
=
store32_le_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 308,
"start_col": 0,
"start_line": 300
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 4} -> z: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowStar.Endianness.store32_le_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.l... | [] | false | true | false | false | false | let store32_le (b: B.buffer UInt8.t {B.length b == 4}) (z: UInt32.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt32.v z)) =
| store32_le_i b 0ul z | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.bytes32 | val bytes32 : t: Type0{Prims.hasEq t} | let bytes32 = B32.bytes | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 7,
"start_col": 0,
"start_line": 7
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: Type0{Prims.hasEq t} | Prims.Tot | [
"total"
] | [] | [
"FStar.Bytes.bytes"
] | [] | false | false | false | false | false | let bytes32 =
| B32.bytes | false | |
LowStar.Endianness.fst | LowStar.Endianness.load32_be | val load32_be (b: B.buffer UInt8.t {B.length b == 4})
: Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt32.v z)) | val load32_be (b: B.buffer UInt8.t {B.length b == 4})
: Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt32.v z)) | let load32_be
(b:B.buffer UInt8.t{B.length b == 4}):
Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt32.v z))
=
load32_be_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 337,
"start_col": 0,
"start_line": 330
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 4}
-> FStar.HyperStack.ST.Stack FStar.UInt32.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load32_be_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u32",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monoton... | [] | false | true | false | false | false | let load32_be (b: B.buffer UInt8.t {B.length b == 4})
: Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt32.v z)) =
| load32_be_i b 0ul | false |
LowStar.Endianness.fst | LowStar.Endianness.store32_be | val store32_be (b: B.buffer UInt8.t {B.length b == 4}) (z: UInt32.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt32.v z)) | val store32_be (b: B.buffer UInt8.t {B.length b == 4}) (z: UInt32.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt32.v z)) | let store32_be
(b:B.buffer UInt8.t{B.length b == 4})
(z:UInt32.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt32.v z))
=
store32_be_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 328,
"start_col": 0,
"start_line": 320
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 4} -> z: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowStar.Endianness.store32_be_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.l... | [] | false | true | false | false | false | let store32_be (b: B.buffer UInt8.t {B.length b == 4}) (z: UInt32.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt32.v z)) =
| store32_be_i b 0ul z | false |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.alloca | val alloca: alloca_st (|Blake2S, M32|) | val alloca: alloca_st (|Blake2S, M32|) | let alloca () =
let h0 = ST.get() in
let s = Hacl.Impl.Blake2.Core.alloc_state Spec.Blake2.Blake2S M32 in
BlS32.init s 0ul 32ul;
let h1 = ST.get () in
B.modifies_only_not_unused_in (B.loc_none) h0 h1;
assert (B.modifies B.loc_none h0 h1);
s | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 22,
"start_col": 0,
"start_line": 15
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash
let malloc = BlS32.malloc_with_key | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.alloca_st (| Spec.Hash.Definitions.Blake2S, Hacl.Impl.Blake2.Core.M32 |) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims._assert",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"LowStar.Monotonic.Buffer.modifies_only_not_unused_in",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definition... | [] | false | false | false | false | false | let alloca () =
| let h0 = ST.get () in
let s = Hacl.Impl.Blake2.Core.alloc_state Spec.Blake2.Blake2S M32 in
BlS32.init s 0ul 32ul;
let h1 = ST.get () in
B.modifies_only_not_unused_in (B.loc_none) h0 h1;
assert (B.modifies B.loc_none h0 h1);
s | false |
LowStar.Endianness.fst | LowStar.Endianness.store128_le | val store128_le (b: B.buffer UInt8.t {B.length b == 16}) (z: UInt128.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt128.v z)) | val store128_le (b: B.buffer UInt8.t {B.length b == 16}) (z: UInt128.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt128.v z)) | let store128_le
(b:B.buffer UInt8.t{B.length b == 16})
(z:UInt128.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt128.v z))
=
store128_le_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 397,
"start_col": 0,
"start_line": 389
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 16} ->
z: FStar.UInt128.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt128.t",
"LowStar.Endianness.store128_le_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer... | [] | false | true | false | false | false | let store128_le (b: B.buffer UInt8.t {B.length b == 16}) (z: UInt128.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt128.v z)) =
| store128_le_i b 0ul z | false |
LowStar.Endianness.fst | LowStar.Endianness.load64_be | val load64_be (b: B.buffer UInt8.t {B.length b == 8})
: Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt64.v z)) | val load64_be (b: B.buffer UInt8.t {B.length b == 8})
: Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt64.v z)) | let load64_be
(b:B.buffer UInt8.t{B.length b == 8}):
Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt64.v z))
=
load64_be_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 367,
"start_col": 0,
"start_line": 360
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 8}
-> FStar.HyperStack.ST.Stack FStar.UInt64.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load64_be_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u64",
"FStar.UInt64.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monoton... | [] | false | true | false | false | false | let load64_be (b: B.buffer UInt8.t {B.length b == 8})
: Stack UInt64.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt64.v z)) =
| load64_be_i b 0ul | false |
LowStar.Endianness.fst | LowStar.Endianness.store64_le | val store64_le (b: B.buffer UInt8.t {B.length b == 8}) (z: UInt64.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt64.v z)) | val store64_le (b: B.buffer UInt8.t {B.length b == 8}) (z: UInt64.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt64.v z)) | let store64_le
(b:B.buffer UInt8.t{B.length b == 8})
(z:UInt64.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt64.v z))
=
store64_le_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 348,
"start_col": 0,
"start_line": 340
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 8} -> z: FStar.UInt64.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt64.t",
"LowStar.Endianness.store64_le_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.l... | [] | false | true | false | false | false | let store64_le (b: B.buffer UInt8.t {B.length b == 8}) (z: UInt64.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt64.v z)) =
| store64_le_i b 0ul z | false |
LowStar.Endianness.fst | LowStar.Endianness.store64_be | val store64_be (b: B.buffer UInt8.t {B.length b == 8}) (z: UInt64.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt64.v z)) | val store64_be (b: B.buffer UInt8.t {B.length b == 8}) (z: UInt64.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt64.v z)) | let store64_be
(b:B.buffer UInt8.t{B.length b == 8})
(z:UInt64.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt64.v z))
=
store64_be_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 377,
"start_col": 0,
"start_line": 369
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 8} -> z: FStar.UInt64.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt64.t",
"LowStar.Endianness.store64_be_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.l... | [] | false | true | false | false | false | let store64_be (b: B.buffer UInt8.t {B.length b == 8}) (z: UInt64.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt64.v z)) =
| store64_be_i b 0ul z | false |
LowStar.Endianness.fst | LowStar.Endianness.store16_be | val store16_be (b: B.buffer UInt8.t {B.length b == 2}) (z: UInt16.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt16.v z)) | val store16_be (b: B.buffer UInt8.t {B.length b == 2}) (z: UInt16.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt16.v z)) | let store16_be
(b:B.buffer UInt8.t{B.length b == 2})
(z:UInt16.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt16.v z))
=
store16_be_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 288,
"start_col": 0,
"start_line": 280
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 2} -> z: FStar.UInt16.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt16.t",
"LowStar.Endianness.store16_be_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.l... | [] | false | true | false | false | false | let store16_be (b: B.buffer UInt8.t {B.length b == 2}) (z: UInt16.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt16.v z)) =
| store16_be_i b 0ul z | false |
LowStar.Endianness.fst | LowStar.Endianness.load128_be | val load128_be (b: B.buffer UInt8.t {B.length b == 16})
: Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt128.v z)) | val load128_be (b: B.buffer UInt8.t {B.length b == 16})
: Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt128.v z)) | let load128_be
(b:B.buffer UInt8.t{B.length b == 16}):
Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt128.v z))
=
load128_be_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 407,
"start_col": 0,
"start_line": 400
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 16}
-> FStar.HyperStack.ST.Stack FStar.UInt128.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load128_be_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u128",
"FStar.UInt128.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Mono... | [] | false | true | false | false | false | let load128_be (b: B.buffer UInt8.t {B.length b == 16})
: Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ be_to_n (B.as_seq h1 b) == UInt128.v z)) =
| load128_be_i b 0ul | false |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.finish | val finish: finish_st (|Blake2S, M32|) | val finish: finish_st (|Blake2S, M32|) | let finish s dst = BlS32.finish (hash_len Blake2S) dst s | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 38,
"start_col": 0,
"start_line": 38
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash
let malloc = BlS32.malloc_with_key
let alloca () =
let h0 = ST.get() in
let s = Hacl.Imp... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.finish_st (| Spec.Hash.Definitions.Blake2S, Hacl.Impl.Blake2.Core.M32 |) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Definitions.hash_t",
"Hacl.Hash.Definitions.get_alg",
"Hacl.Blake2s_32.finish",
"Hacl.Hash.Definitions.hash_l... | [] | false | false | false | false | false | let finish s dst =
| BlS32.finish (hash_len Blake2S) dst s | false |
LowStar.Endianness.fst | LowStar.Endianness.load32_le | val load32_le (b: B.buffer UInt8.t {B.length b == 4})
: Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt32.v z)) | val load32_le (b: B.buffer UInt8.t {B.length b == 4})
: Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt32.v z)) | let load32_le
(b:B.buffer UInt8.t{B.length b == 4}):
Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt32.v z))
=
load32_le_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 317,
"start_col": 0,
"start_line": 310
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 4}
-> FStar.HyperStack.ST.Stack FStar.UInt32.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load32_le_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u32",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monoton... | [] | false | true | false | false | false | let load32_le (b: B.buffer UInt8.t {B.length b == 4})
: Stack UInt32.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt32.v z)) =
| load32_le_i b 0ul | false |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.update_multi | val update_multi: update_multi_st (|Blake2S, M32|) | val update_multi: update_multi_st (|Blake2S, M32|) | let update_multi s ev blocks n =
ST.push_frame ();
let wv = Hacl.Impl.Blake2.Core.alloc_state Spec.Blake2.Blake2S M32 in
BlS32.update_multi #(n `FStar.UInt32.mul` block_len Blake2S) wv s (secret ev) blocks n;
ST.pop_frame () | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 30,
"start_col": 0,
"start_line": 26
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash
let malloc = BlS32.malloc_with_key
let alloca () =
let h0 = ST.get() in
let s = Hacl.Imp... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.update_multi_st (| Spec.Hash.Definitions.Blake2S, Hacl.Impl.Blake2.Core.M32 |) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Definitions.extra_state",
"Hacl.Hash.Definitions.get_alg",
"Hacl.Hash.Definitions.blocks_t",
"Lib.IntTypes.si... | [] | false | false | false | false | false | let update_multi s ev blocks n =
| ST.push_frame ();
let wv = Hacl.Impl.Blake2.Core.alloc_state Spec.Blake2.Blake2S M32 in
BlS32.update_multi #(n `FStar.UInt32.mul` (block_len Blake2S)) wv s (secret ev) blocks n;
ST.pop_frame () | false |
LowStar.Endianness.fst | LowStar.Endianness.index_64_be | val index_64_be (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u64
(requires fun h -> MB.live h b /\ MB.length b % 8 = 0 /\ U32.v i < MB.length b / 8)
(ensures
fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_be (MB.length b / 8) (MB.as_seq h0 b)... | val index_64_be (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u64
(requires fun h -> MB.live h b /\ MB.length b % 8 = 0 /\ U32.v i < MB.length b / 8)
(ensures
fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_be (MB.length b / 8) (MB.as_seq h0 b)... | let index_64_be
(#rrel #rel:MB.srel u8) (b:MB.mbuffer u8 rrel rel)
(i:u32)
: Stack u64
(requires fun h ->
MB.live h b /\ MB.length b % 8 = 0 /\
U32.v i < MB.length b / 8)
(ensures fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_be (MB.length b / 8) (MB.as_seq h0... | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 465,
"start_col": 0,
"start_line": 455
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Monotonic.Buffer.mbuffer LowStar.Endianness.u8 rrel rel -> i: LowStar.Endianness.u32
-> FStar.HyperStack.ST.Stack LowStar.Endianness.u64 | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Endianness.u8",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Endianness.u32",
"LowStar.Endianness.load64_be_i",
"FStar.UInt32.op_Star_Hat",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u64",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Mo... | [] | false | true | false | false | false | let index_64_be (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u64
(requires fun h -> MB.live h b /\ MB.length b % 8 = 0 /\ U32.v i < MB.length b / 8)
(ensures
fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_be (MB.length b / 8) (MB.as_seq h0 b)... | load64_be_i b FStar.UInt32.(8ul *^ i) | false |
LowStar.Endianness.fst | LowStar.Endianness.load16_le | val load16_le (b: B.buffer UInt8.t {B.length b == 2})
: Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt16.v z)) | val load16_le (b: B.buffer UInt8.t {B.length b == 2})
: Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt16.v z)) | let load16_le
(b:B.buffer UInt8.t{B.length b == 2}):
Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt16.v z))
=
load16_le_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 277,
"start_col": 0,
"start_line": 270
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 2}
-> FStar.HyperStack.ST.Stack FStar.UInt16.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load16_le_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u16",
"FStar.UInt16.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monoton... | [] | false | true | false | false | false | let load16_le (b: B.buffer UInt8.t {B.length b == 2})
: Stack UInt16.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt16.v z)) =
| load16_le_i b 0ul | false |
Vale.Math.Poly2.Galois.fst | Vale.Math.Poly2.Galois.lemma_smul_gmul_rec | val lemma_smul_gmul_rec (f: G.field) (e1 e2: G.felem f) (n: nat)
: Lemma
(let p, a, b = gmul_rec f e1 e2 n in
(to_poly p, to_poly a, to_poly b) == smul_rec (to_poly e1) (to_poly e2) (irred_poly f) n) | val lemma_smul_gmul_rec (f: G.field) (e1 e2: G.felem f) (n: nat)
: Lemma
(let p, a, b = gmul_rec f e1 e2 n in
(to_poly p, to_poly a, to_poly b) == smul_rec (to_poly e1) (to_poly e2) (irred_poly f) n) | let rec lemma_smul_gmul_rec (f:G.field) (e1 e2:G.felem f) (n:nat) : Lemma
( let (p, a, b) = gmul_rec f e1 e2 n in
(to_poly p, to_poly a, to_poly b) == smul_rec (to_poly e1) (to_poly e2) (irred_poly f) n)
=
let G.GF t irred = f in
let a = to_poly e1 in
let b = to_poly e2 in
let m = irred_poly f in
lemm... | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 529,
"start_col": 0,
"start_line": 464
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module U = FStar.UInt
module PL = Vale.Math.Poly2.Lemmas
module D = Vale.Math.Poly2.Defs_s
//module PD = Vale.Math.Poly2.Defs
module GI = Vale.Math.Poly2.Galois.IntTypes
// recursive definitions of from_vec/to_vec are prone to matching loops, so use no fuel from here on
#r... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Galois.IntTypes.fsti.checked",
"Vale.Math.Poly2.Defs_s.fst.checked",
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.Compatibility.fst... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: Spec.GaloisField.field ->
e1: Spec.GaloisField.felem f ->
e2: Spec.GaloisField.felem f ->
n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(let _ = Vale.Math.Poly2.Galois.gmul_rec f e1 e2 n in
(let FStar.Pervasives.Native.Mktuple3 #_ #_ #_ p a b = _ in
(Vale.Math.Poly2.G... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.GaloisField.field",
"Spec.GaloisField.felem",
"Prims.nat",
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.op_disEquality",
"Lib.IntTypes.U1",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.op_GreaterThan",
"Vale.Math.Poly2_s.poly",
"Prims.unit"... | [
"recursion"
] | false | false | true | false | false | let rec lemma_smul_gmul_rec (f: G.field) (e1 e2: G.felem f) (n: nat)
: Lemma
(let p, a, b = gmul_rec f e1 e2 n in
(to_poly p, to_poly a, to_poly b) == smul_rec (to_poly e1) (to_poly e2) (irred_poly f) n) =
| let G.GF t irred = f in
let a = to_poly e1 in
let b = to_poly e2 in
let m = irred_poly f in
lemma_zero f;
lemma_one f;
if n > 0
then
(lemma_smul_gmul_rec f e1 e2 (n - 1);
let sp, sa, sb = smul_rec a b m (n - 1) in
let gp, ga, gb = gmul_rec f e1 e2 (n - 1) in
let sp' = sp +. (if sb.[ 0 ] then sa else zero)... | false |
LowStar.Endianness.fst | LowStar.Endianness.load128_le | val load128_le (b: B.buffer UInt8.t {B.length b == 16})
: Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt128.v z)) | val load128_le (b: B.buffer UInt8.t {B.length b == 16})
: Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt128.v z)) | let load128_le
(b:B.buffer UInt8.t{B.length b == 16}):
Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\
le_to_n (B.as_seq h1 b) == UInt128.v z))
=
load128_le_i b 0ul | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 387,
"start_col": 0,
"start_line": 380
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b == 16}
-> FStar.HyperStack.ST.Stack FStar.UInt128.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.eq2",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Endianness.load128_le_i",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u128",
"FStar.UInt128.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Mono... | [] | false | true | false | false | false | let load128_le (b: B.buffer UInt8.t {B.length b == 16})
: Stack UInt128.t
(requires (fun h -> B.live h b))
(ensures (fun h0 z h1 -> h0 == h1 /\ B.live h1 b /\ le_to_n (B.as_seq h1 b) == UInt128.v z)) =
| load128_le_i b 0ul | false |
LowStar.Endianness.fst | LowStar.Endianness.index_32_le | val index_32_le (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u32
(requires fun h -> MB.live h b /\ MB.length b % 4 = 0 /\ U32.v i < MB.length b / 4)
(ensures
fun h0 r h1 ->
h0 == h1 /\ r = Seq.index (seq_uint32_of_le (MB.length b / 4) (MB.as_seq h0 b)) (U32.v i... | val index_32_le (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u32
(requires fun h -> MB.live h b /\ MB.length b % 4 = 0 /\ U32.v i < MB.length b / 4)
(ensures
fun h0 r h1 ->
h0 == h1 /\ r = Seq.index (seq_uint32_of_le (MB.length b / 4) (MB.as_seq h0 b)) (U32.v i... | let index_32_le
(#rrel #rel:MB.srel u8) (b:MB.mbuffer u8 rrel rel)
(i:u32)
: Stack u32
(requires fun h ->
MB.live h b /\ MB.length b % 4 = 0 /\
U32.v i < MB.length b / 4)
(ensures fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint32_of_le (MB.length b / 4) (MB.as_seq h0... | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 452,
"start_col": 0,
"start_line": 442
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Monotonic.Buffer.mbuffer LowStar.Endianness.u8 rrel rel -> i: LowStar.Endianness.u32
-> FStar.HyperStack.ST.Stack LowStar.Endianness.u32 | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Endianness.u8",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Endianness.u32",
"LowStar.Endianness.load32_le_i",
"FStar.UInt32.op_Star_Hat",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"Pri... | [] | false | true | false | false | false | let index_32_le (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u32
(requires fun h -> MB.live h b /\ MB.length b % 4 = 0 /\ U32.v i < MB.length b / 4)
(ensures
fun h0 r h1 ->
h0 == h1 /\ r = Seq.index (seq_uint32_of_le (MB.length b / 4) (MB.as_seq h0 b)) (U32.v i... | load32_le_i b FStar.UInt32.(4ul *^ i) | false |
LowStar.Endianness.fst | LowStar.Endianness.store128_be | val store128_be (b: B.buffer UInt8.t {B.length b = 16}) (z: UInt128.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt128.v z)) | val store128_be (b: B.buffer UInt8.t {B.length b = 16}) (z: UInt128.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt128.v z)) | let store128_be
(b:B.buffer UInt8.t{B.length b = 16})
(z:UInt128.t):
Stack unit
(requires (fun h -> B.live h b))
(ensures (fun h0 _ h1 -> B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt128.v z))
=
store128_be_i b 0ul z | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 417,
"start_col": 0,
"start_line": 409
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b = 16} ->
z: FStar.UInt128.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt128.t",
"LowStar.Endianness.store128_be_i",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"L... | [] | false | true | false | false | false | let store128_be (b: B.buffer UInt8.t {B.length b = 16}) (z: UInt128.t)
: Stack unit
(requires (fun h -> B.live h b))
(ensures
(fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ B.live h1 b /\
be_to_n (B.as_seq h1 b) == UInt128.v z)) =
| store128_be_i b 0ul z | false |
LowStar.Endianness.fst | LowStar.Endianness.index_32_be | val index_32_be (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u32
(requires fun h -> MB.live h b /\ MB.length b % 4 = 0 /\ U32.v i < MB.length b / 4)
(ensures
fun h0 r h1 ->
h0 == h1 /\ r = Seq.index (seq_uint32_of_be (MB.length b / 4) (MB.as_seq h0 b)) (U32.v i... | val index_32_be (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u32
(requires fun h -> MB.live h b /\ MB.length b % 4 = 0 /\ U32.v i < MB.length b / 4)
(ensures
fun h0 r h1 ->
h0 == h1 /\ r = Seq.index (seq_uint32_of_be (MB.length b / 4) (MB.as_seq h0 b)) (U32.v i... | let index_32_be
(#rrel #rel:MB.srel u8) (b:MB.mbuffer u8 rrel rel)
(i:u32)
: Stack u32
(requires fun h ->
MB.live h b /\ MB.length b % 4 = 0 /\
U32.v i < MB.length b / 4)
(ensures fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint32_of_be (MB.length b / 4) (MB.as_seq h0... | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 439,
"start_col": 0,
"start_line": 429
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Monotonic.Buffer.mbuffer LowStar.Endianness.u8 rrel rel -> i: LowStar.Endianness.u32
-> FStar.HyperStack.ST.Stack LowStar.Endianness.u32 | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Endianness.u8",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Endianness.u32",
"LowStar.Endianness.load32_be_i",
"FStar.UInt32.op_Star_Hat",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"Pri... | [] | false | true | false | false | false | let index_32_be (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u32
(requires fun h -> MB.live h b /\ MB.length b % 4 = 0 /\ U32.v i < MB.length b / 4)
(ensures
fun h0 r h1 ->
h0 == h1 /\ r = Seq.index (seq_uint32_of_be (MB.length b / 4) (MB.as_seq h0 b)) (U32.v i... | load32_be_i b FStar.UInt32.(4ul *^ i) | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.serializer32_correct | val serializer32_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0 | val serializer32_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0 | let serializer32_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0
= B32.reveal res == s input | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 108,
"start_col": 0,
"start_line": 100
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes
let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: LowParse.Spec.Base.serializer p -> input: t -> res: LowParse.SLow.Base.bytes32
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.bytes32",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Bytes.byte",
"FStar.Bytes.reveal"
] | [] | false | false | false | false | true | let serializer32_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0 =
| B32.reveal res == s input | false |
LowStar.Endianness.fst | LowStar.Endianness.index_64_le | val index_64_le (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u64
(requires fun h -> MB.live h b /\ MB.length b % 8 = 0 /\ U32.v i < MB.length b / 8)
(ensures
fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_le (MB.length b / 8) (MB.as_seq h0 b)... | val index_64_le (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u64
(requires fun h -> MB.live h b /\ MB.length b % 8 = 0 /\ U32.v i < MB.length b / 8)
(ensures
fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_le (MB.length b / 8) (MB.as_seq h0 b)... | let index_64_le
(#rrel #rel:MB.srel u8) (b:MB.mbuffer u8 rrel rel)
(i:u32)
: Stack u64
(requires fun h ->
MB.live h b /\ MB.length b % 8 = 0 /\
U32.v i < MB.length b / 8)
(ensures fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_le (MB.length b / 8) (MB.as_seq h0... | {
"file_name": "ulib/LowStar.Endianness.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 478,
"start_col": 0,
"start_line": 468
} | module LowStar.Endianness
/// Stateful operations between machine integers and buffers of uint8s. Most of
/// these operations are implemented natively using the target's system endianness
/// headers, relying on macros or static inline declarations.
///
/// .. note::
///
/// This module supersedes ``C.Endianness``... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Monotonic.Buffer.mbuffer LowStar.Endianness.u8 rrel rel -> i: LowStar.Endianness.u32
-> FStar.HyperStack.ST.Stack LowStar.Endianness.u64 | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Endianness.u8",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Endianness.u32",
"LowStar.Endianness.load64_le_i",
"FStar.UInt32.op_Star_Hat",
"FStar.UInt32.__uint_to_t",
"LowStar.Endianness.u64",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Mo... | [] | false | true | false | false | false | let index_64_le (#rrel #rel: MB.srel u8) (b: MB.mbuffer u8 rrel rel) (i: u32)
: Stack u64
(requires fun h -> MB.live h b /\ MB.length b % 8 = 0 /\ U32.v i < MB.length b / 8)
(ensures
fun h0 r h1 ->
h0 == h1 /\
r = Seq.index (seq_uint64_of_le (MB.length b / 8) (MB.as_seq h0 b)... | load64_le_i b FStar.UInt32.(8ul *^ i) | false |
Hacl.Hash.Blake2s_32.fst | Hacl.Hash.Blake2s_32.update_last | val update_last: update_last_st (|Blake2S, M32|) | val update_last: update_last_st (|Blake2S, M32|) | let update_last s prev input input_len =
ST.push_frame ();
let wv = Hacl.Impl.Blake2.Core.alloc_state Spec.Blake2.Blake2S M32 in
BlS32.update_last #input_len wv s (secret prev) input_len input;
ST.pop_frame() | {
"file_name": "code/hash/Hacl.Hash.Blake2s_32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 36,
"start_col": 0,
"start_line": 32
} | module Hacl.Hash.Blake2s_32
module B = LowStar.Buffer
module ST = FStar.HyperStack.ST
module BlS32 = Hacl.Blake2s_32
open Lib.IntTypes
open Lib.Buffer
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
friend Spec.Agile.Hash
let malloc = BlS32.malloc_with_key
let alloca () =
let h0 = ST.get() in
let s = Hacl.Imp... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"Spec.Agile.Hash.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Blake2s_32.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",... | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "BlS32"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Hash.Definitions.update_last_st (| Spec.Hash.Definitions.Blake2S, Hacl.Impl.Blake2.Core.M32 |) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Definitions.prev_len_t",
"Hacl.Hash.Definitions.get_alg",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"P... | [] | false | false | false | false | false | let update_last s prev input input_len =
| ST.push_frame ();
let wv = Hacl.Impl.Blake2.Core.alloc_state Spec.Blake2.Blake2S M32 in
BlS32.update_last #input_len wv s (secret prev) input_len input;
ST.pop_frame () | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.serializer32_correct' | val serializer32_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0 | val serializer32_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0 | let serializer32_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0
= B32.reveal res `bytes_equal` s input | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 118,
"start_col": 0,
"start_line": 110
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes
let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: LowParse.Spec.Base.serializer p -> input: t -> res: LowParse.SLow.Base.bytes32
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.bytes32",
"LowParse.Bytes.bytes_equal",
"FStar.Bytes.reveal"
] | [] | false | false | false | false | true | let serializer32_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: t)
(res: bytes32)
: GTot Type0 =
| (B32.reveal res) `bytes_equal` (s input) | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.make_parser32 | val make_parser32
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(p32:
(input: bytes32
-> Pure (option (t * U32.t))
(requires True)
(ensures (fun res -> parser32_correct p input res))))
: Tot (parser32 p) | val make_parser32
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(p32:
(input: bytes32
-> Pure (option (t * U32.t))
(requires True)
(ensures (fun res -> parser32_correct p input res))))
: Tot (parser32 p) | let make_parser32
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(p32: (input: bytes32) -> Pure (option (t * U32.t)) (requires True) (ensures (fun res -> parser32_correct p input res)))
: Tot (parser32 p)
= (fun (input: bytes32) -> (p32 input <: (res: option (t * U32.t) { parser32_correct p input res } ))) | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 102,
"end_line": 64,
"start_col": 0,
"start_line": 58
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes
let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: LowParse.Spec.Base.parser k t ->
p32:
(input: LowParse.SLow.Base.bytes32
-> Prims.Pure (FStar.Pervasives.Native.option (t * FStar.UInt32.t)))
-> LowParse.SLow.Base.parser32 p | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"Prims.l_True",
"LowParse.SLow.Base.parser32_correct",
"LowParse.SLow.Base.parser32"
] | [] | false | false | false | false | false | let make_parser32
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(p32:
(input: bytes32
-> Pure (option (t * U32.t))
(requires True)
(ensures (fun res -> parser32_correct p input res))))
: Tot (parser32 p) =
| (fun (input: bytes32) -> (p32 input <: (res: option (t * U32.t) {parser32_correct p input res}))) | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.parser32_correct | val parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0 | val parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0 | let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res with
| None -> gp == None
| Some (hres, consumed) ->
Some? gp /\ (
let (Some (hres' , consumed')) = gp in
hres == h... | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 24,
"start_col": 0,
"start_line": 9
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: LowParse.Spec.Base.parser k t ->
input: LowParse.SLow.Base.bytes32 ->
res: FStar.Pervasives.Native.option (t * FStar.UInt32.t)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"Prims.eq2",
"LowParse.Spec.Base.consumed_length",
"FStar.Bytes.reveal",
"FStar.Pervasives.Native.None",
"Prims.l_and... | [] | false | false | false | false | true | let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0 =
| let gp = parse p (B32.reveal input) in
match res with
| None -> gp == None
| Some (hres, consumed) ->
Some? gp /\
(let Some (hres', consumed') = gp in
hres == hres' /\ U32.v consumed == (consumed' <: nat)) | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.coerce_parser32 | val coerce_parser32
(t2: Type)
(#k: parser_kind)
(#t1: Type)
(#p: parser k t1)
(p32: parser32 p)
(u: unit{t2 == t1})
: Tot (parser32 (coerce_parser t2 p)) | val coerce_parser32
(t2: Type)
(#k: parser_kind)
(#t1: Type)
(#p: parser k t1)
(p32: parser32 p)
(u: unit{t2 == t1})
: Tot (parser32 (coerce_parser t2 p)) | let coerce_parser32
(t2: Type)
(#k: parser_kind)
(#t1: Type)
(#p: parser k t1)
(p32: parser32 p)
(u: unit { t2 == t1 } )
: Tot (parser32 (coerce_parser t2 p))
= p32 | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 75,
"start_col": 0,
"start_line": 67
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes
let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t2: Type -> p32: LowParse.SLow.Base.parser32 p -> u71: u72: Prims.unit{t2 == t1}
-> LowParse.SLow.Base.parser32 (LowParse.Spec.Base.coerce_parser t2 p) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"Prims.unit",
"Prims.eq2",
"LowParse.Spec.Base.coerce_parser"
] | [] | false | false | false | false | false | let coerce_parser32
(t2: Type)
(#k: parser_kind)
(#t1: Type)
(#p: parser k t1)
(p32: parser32 p)
(u: unit{t2 == t1})
: Tot (parser32 (coerce_parser t2 p)) =
| p32 | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.validator_correct | val validator_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option U32.t)
: GTot Type0 | val validator_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option U32.t)
: GTot Type0 | let validator_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option U32.t)
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res with
| None -> gp == None
| Some (consumed) ->
Some? gp /\ (
let (Some (_ , consumed')) = gp in
U32.v consumed == (consu... | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 91,
"start_col": 0,
"start_line": 77
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes
let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: LowParse.Spec.Base.parser k t ->
input: LowParse.SLow.Base.bytes32 ->
res: FStar.Pervasives.Native.option FStar.UInt32.t
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.UInt32.t",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"FStar.Bytes.reveal",
"FStar.Pervasives.Native.None",
"Prims.l_and... | [] | false | false | false | false | true | let validator_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option U32.t)
: GTot Type0 =
| let gp = parse p (B32.reveal input) in
match res with
| None -> gp == None
| Some consumed ->
Some? gp /\
(let Some (_, consumed') = gp in
U32.v consumed == (consumed' <: nat)) | false |
LowParse.SLow.Base.fst | LowParse.SLow.Base.serialize32_ext | val serialize32_ext
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash (t1 == t2 /\ (forall (input: bytes). parse p1 input == parse p2 input)))
: Tot (serializ... | val serialize32_ext
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash (t1 == t2 /\ (forall (input: bytes). parse p1 input == parse p2 input)))
: Tot (serializ... | let serialize32_ext
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input)))
: Tot (serializer32 (serialize_ext p1 s1 p2))
= fun in... | {
"file_name": "src/lowparse/LowParse.SLow.Base.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 24,
"end_line": 161,
"start_col": 0,
"start_line": 150
} | module LowParse.SLow.Base
include LowParse.Spec.Base
module B32 = LowParse.Bytes32
module U32 = FStar.UInt32
let bytes32 = B32.bytes
let parser32_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes32)
(res: option (t * U32.t))
: GTot Type0
= let gp = parse p (B32.reveal input) in
match res... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked... | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Bytes32",
"short_module": "B32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
s1: LowParse.Spec.Base.serializer p1 ->
s1': LowParse.SLow.Base.serializer32 s1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
u158:
Prims.squash (t1 == t2 /\
(forall (input: LowParse.Bytes.bytes).
LowParse.Spec.Base.parse p1 input == ... | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.serializer32",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse... | [] | false | false | false | false | false | let serialize32_ext
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash (t1 == t2 /\ (forall (input: bytes). parse p1 input == parse p2 input)))
: Tot (serializ... | fun input -> s1' input | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.