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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
AlgHeap.fst | AlgHeap.equiv | val equiv : w1: AlgHeap.st_wp a -> w2: AlgHeap.st_wp a -> Prims.logical | let equiv #a (w1 w2 : st_wp a) = w1 `stronger` w2 /\ w2 `stronger` w1 | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 262,
"start_col": 0,
"start_line": 262
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.st_wp a -> w2: AlgHeap.st_wp a -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.st_wp",
"Prims.l_and",
"AlgHeap.stronger",
"Prims.logical"
] | [] | false | false | false | true | true | let equiv #a (w1: st_wp a) (w2: st_wp a) =
| w1 `stronger` w2 /\ w2 `stronger` w1 | false | |
AlgHeap.fst | AlgHeap._get | val _get:tree state [Read] | val _get:tree state [Read] | let _get : tree state [Read] = Op Read () Return | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 174,
"start_col": 0,
"start_line": 174
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 | AlgHeap.tree AlgHeap.state [AlgHeap.Read] | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.Op",
"AlgHeap.state",
"AlgHeap.Read",
"AlgHeap.Return"
] | [] | false | false | false | true | false | let _get:tree state [Read] =
| Op Read () Return | false |
AlgHeap.fst | AlgHeap.fold_with | val fold_with (#a #b:_) (#labs : ops)
(f:tree a labs)
(v : a -> b)
(h: (o:op{mem o labs} -> op_inp o -> (op_out o -> b) -> b))
: b | val fold_with (#a #b:_) (#labs : ops)
(f:tree a labs)
(v : a -> b)
(h: (o:op{mem o labs} -> op_inp o -> (op_out o -> b) -> b))
: b | let rec fold_with #a #b #labs f v h =
match f with
| Return x -> v x
| Op act i k ->
let k' (o : op_out act) : b =
fold_with #_ #_ #labs (k o) v h
in
h act i k' | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 129,
"start_col": 0,
"start_line": 122
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.tree a labs ->
v: (_: a -> b) ->
h:
(
o: AlgHeap.op{FStar.List.Tot.Base.mem o labs} ->
_: AlgHeap.op_inp o ->
_: (_: AlgHeap.op_out o -> b)
-> b)
-> b | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.ops",
"AlgHeap.tree",
"AlgHeap.op",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"AlgHeap.op_inp",
"AlgHeap.op_out",
"AlgHeap.tree0",
"AlgHeap.fold_with"
] | [
"recursion"
] | false | false | false | false | false | let rec fold_with #a #b #labs f v h =
| match f with
| Return x -> v x
| Op act i k ->
let k' (o: op_out act) : b = fold_with #_ #_ #labs (k o) v h in
h act i k' | false |
AlgHeap.fst | AlgHeap.get | val get: Prims.unit -> Alg state [Read] | val get: Prims.unit -> Alg state [Read] | let get () : Alg state [Read] =
Alg?.reflect _get | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 187,
"start_col": 0,
"start_line": 186
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 | _: Prims.unit -> AlgHeap.Alg AlgHeap.state | AlgHeap.Alg | [] | [] | [
"Prims.unit",
"AlgHeap._get",
"AlgHeap.state",
"Prims.Cons",
"AlgHeap.op",
"AlgHeap.Read",
"Prims.Nil"
] | [] | false | true | false | false | false | let get () : Alg state [Read] =
| Alg?.reflect _get | false |
AlgHeap.fst | AlgHeap.put | val put (s: state) : Alg unit [Write] | val put (s: state) : Alg unit [Write] | let put (s:state) : Alg unit [Write] =
Alg?.reflect (_put s) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 202,
"start_col": 0,
"start_line": 201
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.state -> AlgHeap.Alg Prims.unit | AlgHeap.Alg | [] | [] | [
"AlgHeap.state",
"AlgHeap._put",
"Prims.unit",
"Prims.Cons",
"AlgHeap.op",
"AlgHeap.Write",
"Prims.Nil"
] | [] | false | true | false | false | false | let put (s: state) : Alg unit [Write] =
| Alg?.reflect (_put s) | false |
AlgHeap.fst | AlgHeap.repr | val repr : a: Type -> w: AlgHeap.st_wp a -> Type | let repr (a : Type) (w: st_wp a) =
c:(rwtree a){w `stronger` interp_as_wp c} | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 341,
"start_col": 0,
"start_line": 340
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.st_wp a -> Type | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.st_wp",
"AlgHeap.rwtree",
"AlgHeap.stronger",
"AlgHeap.interp_as_wp"
] | [] | false | false | false | true | true | let repr (a: Type) (w: st_wp a) =
| c: (rwtree a){w `stronger` (interp_as_wp c)} | false | |
AlgHeap.fst | AlgHeap.tbind | val tbind: #a: _ -> #b: _ -> rwtree a -> (a -> rwtree b) -> rwtree b | val tbind: #a: _ -> #b: _ -> rwtree a -> (a -> rwtree b) -> rwtree b | let tbind : #a:_ -> #b:_ -> rwtree a -> (a -> rwtree b) -> rwtree b = fun c f -> bind _ _ c f | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 212,
"start_col": 0,
"start_line": 212
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.rwtree a -> f: (_: a -> AlgHeap.rwtree b) -> AlgHeap.rwtree b | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.rwtree",
"AlgHeap.bind",
"Prims.Cons",
"AlgHeap.op",
"AlgHeap.Read",
"AlgHeap.Write",
"Prims.Nil"
] | [] | false | false | false | true | false | let tbind: #a: _ -> #b: _ -> rwtree a -> (a -> rwtree b) -> rwtree b =
| fun c f -> bind _ _ c f | false |
AlgHeap.fst | AlgHeap.subcomp | val subcomp (a: Type) (labs1 labs2: ops) (f: tree a labs1)
: Pure (tree a labs2) (requires (sublist labs1 labs2)) (ensures (fun _ -> True)) | val subcomp (a: Type) (labs1 labs2: ops) (f: tree a labs1)
: Pure (tree a labs2) (requires (sublist labs1 labs2)) (ensures (fun _ -> True)) | let subcomp (a:Type)
(labs1 labs2 : ops)
(f : tree a labs1)
: Pure (tree a labs2)
(requires (sublist labs1 labs2))
(ensures (fun _ -> True))
= f | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 163,
"start_col": 0,
"start_line": 157
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 -> labs1: AlgHeap.ops -> labs2: AlgHeap.ops -> f: AlgHeap.tree a labs1
-> Prims.Pure (AlgHeap.tree a labs2) | Prims.Pure | [] | [] | [
"AlgHeap.ops",
"AlgHeap.tree",
"AlgHeap.sublist",
"Prims.l_True"
] | [] | false | false | false | false | false | let subcomp (a: Type) (labs1 labs2: ops) (f: tree a labs1)
: Pure (tree a labs2) (requires (sublist labs1 labs2)) (ensures (fun _ -> True)) =
| f | false |
AlgHeap.fst | AlgHeap._put | val _put (s: state) : tree unit [Write] | val _put (s: state) : tree unit [Write] | let _put (s:state) : tree unit [Write] = Op Write s Return | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 176,
"start_col": 0,
"start_line": 176
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.state -> AlgHeap.tree Prims.unit [AlgHeap.Write] | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.state",
"AlgHeap.Op",
"Prims.unit",
"AlgHeap.Write",
"AlgHeap.Return",
"AlgHeap.tree",
"Prims.Cons",
"AlgHeap.op",
"Prims.Nil"
] | [] | false | false | false | true | false | let _put (s: state) : tree unit [Write] =
| Op Write s Return | false |
Hacl.Impl.RSAPSS.fst | Hacl.Impl.RSAPSS.rsapss_sign_compute_sgnt | val rsapss_sign_compute_sgnt:
#t:limb_t
-> ke:BE.exp t
-> modBits:modBits_t t ->
rsapss_sign_compute_sgnt_st t ke modBits | val rsapss_sign_compute_sgnt:
#t:limb_t
-> ke:BE.exp t
-> modBits:modBits_t t ->
rsapss_sign_compute_sgnt_st t ke modBits | let rsapss_sign_compute_sgnt #t ke modBits eBits dBits skey m sgnt =
push_frame ();
let h_init = ST.get () in
[@inline_let] let bits : size_pos = bits t in
[@inline_let] let numb : size_pos = numbytes t in
let nLen = blocks modBits (size bits) in
let k = blocks modBits 8ul in
let s = create nLen (uint #t... | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 181,
"start_col": 0,
"start_line": 164
} | module Hacl.Impl.RSAPSS
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module Hash = Spec.Agile.Hash
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module SD = Hacl.Spec.Bignum.Definitions
... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.Keys",
"short_module": "RK"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.MGF",
"short_module": "RM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.Padding",
"short_module": "RP"
},
{
"abbrev": true... | {
"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 | ke: Hacl.Bignum.Exponentiation.exp t -> modBits: Hacl.Impl.RSAPSS.modBits_t t
-> Hacl.Impl.RSAPSS.rsapss_sign_compute_sgnt_st t ke modBits | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Hacl.Impl.RSAPSS.modBits_t",
"Lib.IntTypes.size_t",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.op_Sta... | [] | false | false | false | false | false | let rsapss_sign_compute_sgnt #t ke modBits eBits dBits skey m sgnt =
| push_frame ();
let h_init = ST.get () in
[@@ inline_let ]let bits:size_pos = bits t in
[@@ inline_let ]let numb:size_pos = numbytes t in
let nLen = blocks modBits (size bits) in
let k = blocks modBits 8ul in
let s = create nLen (uint #t 0) in
let m' = create nLen (uint #t 0) in
let eq_b = rsapss_sign_bn ke modBits eBit... | false |
AlgHeap.fst | AlgHeap.raise | val raise (#a: _) (e: exn) : Alg a [Raise] | val raise (#a: _) (e: exn) : Alg a [Raise] | let raise #a (e:exn) : Alg a [Raise] =
Alg?.reflect (Op Raise e (fun e -> match e with)) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 205,
"start_col": 0,
"start_line": 204
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 | e: Prims.exn -> AlgHeap.Alg a | AlgHeap.Alg | [] | [] | [
"Prims.exn",
"AlgHeap.Op",
"AlgHeap.Raise",
"AlgHeap.op_out",
"AlgHeap.tree0",
"Prims.Cons",
"AlgHeap.op",
"Prims.Nil"
] | [] | false | true | false | false | false | let raise #a (e: exn) : Alg a [Raise] =
| Alg?.reflect (Op Raise e (function )) | false |
SolveThen.fst | SolveThen.f3 | val f3:int | val f3:int | let f3 : int = _ by (fib 3) | {
"file_name": "examples/tactics/SolveThen.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 22,
"start_col": 0,
"start_line": 22
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SolveThen.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | {
"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 | Prims.int | Prims.Tot | [
"total"
] | [] | [
"Prims.op_Addition"
] | [] | false | false | false | true | false | let f3:int =
| FStar.Tactics.Effect.synth_by_tactic (fun _ -> (fib 3)) | false |
Vale.AES.X64.GCMdecryptOpt.fst | Vale.AES.X64.GCMdecryptOpt.va_wpProof_Gcm_blocks_decrypt_stdcall | val va_wpProof_Gcm_blocks_decrypt_stdcall : win:bool -> alg:algorithm -> auth_b:buffer128 ->
auth_bytes:nat64 -> auth_num:nat64 -> keys_b:buffer128 -> iv_b:buffer128 -> iv:supported_iv_LE ->
hkeys_b:buffer128 -> abytes_b:buffer128 -> in128x6_b:buffer128 -> out128x6_b:buffer128 ->
len128x6_num:nat64 -> in128_b:buf... | val va_wpProof_Gcm_blocks_decrypt_stdcall : win:bool -> alg:algorithm -> auth_b:buffer128 ->
auth_bytes:nat64 -> auth_num:nat64 -> keys_b:buffer128 -> iv_b:buffer128 -> iv:supported_iv_LE ->
hkeys_b:buffer128 -> abytes_b:buffer128 -> in128x6_b:buffer128 -> out128x6_b:buffer128 ->
len128x6_num:nat64 -> in128_b:buf... | let va_wpProof_Gcm_blocks_decrypt_stdcall win alg auth_b auth_bytes auth_num keys_b iv_b iv hkeys_b
abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num
scratch_b tag_b key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Gcm_blocks_decrypt_stdcall (va_code_Gcm_blocks_decrypt_stdcal... | {
"file_name": "obj/Vale.AES.X64.GCMdecryptOpt.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 2352,
"start_col": 0,
"start_line": 2321
} | module Vale.AES.X64.GCMdecryptOpt
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GCM
open Vale.AES.GHash_s
open Vale.AE... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Stack.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.In... | [
{
"abbrev": false,
"full_module": "Vale.Lib.Basic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.GCMencryptOpt",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
win: Prims.bool ->
alg: Vale.AES.AES_common_s.algorithm ->
auth_b: Vale.X64.Memory.buffer128 ->
auth_bytes: Vale.X64.Memory.nat64 ->
auth_num: Vale.X64.Memory.nat64 ->
keys_b: Vale.X64.Memory.buffer128 ->
iv_b: Vale.X64.Memory.buffer128 ->
iv: Vale.AES.GCM_s.supported_iv_LE ->
hkeys... | Prims.Ghost | [] | [] | [
"Prims.bool",
"Vale.AES.AES_common_s.algorithm",
"Vale.X64.Memory.buffer128",
"Vale.X64.Memory.nat64",
"Vale.AES.GCM_s.supported_iv_LE",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X... | [] | false | false | false | false | false | let va_wpProof_Gcm_blocks_decrypt_stdcall
win
alg
auth_b
auth_bytes
auth_num
keys_b
iv_b
iv
hkeys_b
abytes_b
in128x6_b
out128x6_b
len128x6_num
in128_b
out128_b
len128_num
inout_b
cipher_num
scratch_b
... | let va_sM, va_f0 =
va_lemma_Gcm_blocks_decrypt_stdcall (va_code_Gcm_blocks_decrypt_stdcall win alg) va_s0 win alg
auth_b auth_bytes auth_num keys_b iv_b iv hkeys_b abytes_b in128x6_b out128x6_b len128x6_num
in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b key
in
va_lemma_upd_update va_sM;
assert... | false |
AlgHeap.fst | AlgHeap.lift_pure_eff | val lift_pure_eff (a: Type) (wp: pure_wp a) (f: (unit -> PURE a wp))
: Pure (tree a []) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) | val lift_pure_eff (a: Type) (wp: pure_wp a) (f: (unit -> PURE a wp))
: Pure (tree a []) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) | let lift_pure_eff
(a:Type)
(wp : pure_wp a)
(f : unit -> PURE a wp)
: Pure (tree a [])
(requires (wp (fun _ -> True)))
(ensures (fun _ -> True))
= FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
Return (f ()) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 197,
"start_col": 0,
"start_line": 189
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 -> wp: Prims.pure_wp a -> f: (_: Prims.unit -> Prims.PURE a)
-> Prims.Pure (AlgHeap.tree a []) | Prims.Pure | [] | [] | [
"Prims.pure_wp",
"Prims.unit",
"AlgHeap.Return",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"AlgHeap.tree",
"Prims.Nil",
"AlgHeap.op",
"Prims.l_True"
] | [] | false | false | false | false | false | let lift_pure_eff (a: Type) (wp: pure_wp a) (f: (unit -> PURE a wp))
: Pure (tree a []) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) =
| FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
Return (f ()) | false |
AlgHeap.fst | AlgHeap.modifies | val modifies (ls: list loc) (h0 h1: state) : Type0 | val modifies (ls: list loc) (h0 h1: state) : Type0 | let modifies (ls: list loc) (h0 h1 : state) : Type0 =
forall y. mem y ls \/ (Map.sel h0 y == Map.sel h1 y) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 417,
"start_col": 0,
"start_line": 416
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | ls: Prims.list AlgHeap.loc -> h0: AlgHeap.state -> h1: AlgHeap.state -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"AlgHeap.loc",
"AlgHeap.state",
"Prims.l_Forall",
"Prims.l_or",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"Prims.eq2",
"Prims.int",
"FStar.Map.sel"
] | [] | false | false | false | true | true | let modifies (ls: list loc) (h0 h1: state) : Type0 =
| forall y. mem y ls \/ (Map.sel h0 y == Map.sel h1 y) | false |
SolveThen.fst | SolveThen.constr | val constr (a b: prop) : squash (a ==> b ==> b /\ a) | val constr (a b: prop) : squash (a ==> b ==> b /\ a) | let constr (a b : prop) : squash (a ==> b ==> b /\ a)
= _ by
(let ha = implies_intro () in
let hb = implies_intro () in
split ();
hyp (binding_to_namedv hb);
hyp (binding_to_namedv ha);
qed ()) | {
"file_name": "examples/tactics/SolveThen.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 34,
"start_col": 0,
"start_line": 27
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SolveThen.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | {
"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: Prims.prop -> b: Prims.prop -> Prims.squash (a ==> b ==> b /\ a) | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"Prims.squash",
"Prims.l_imp",
"Prims.l_and"
] | [] | false | false | true | false | false | let constr (a b: prop) : squash (a ==> b ==> b /\ a) =
| FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(let ha = implies_intro () in
let hb = implies_intro () in
split ();
hyp (binding_to_namedv hb);
hyp (binding_to_namedv ha);
qed ())) | false |
AlgHeap.fst | AlgHeap.write_wp | val write_wp: state -> st_wp unit | val write_wp: state -> st_wp unit | let write_wp : state -> st_wp unit = fun s _ p -> p ((), s) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 235,
"start_col": 0,
"start_line": 235
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.state -> AlgHeap.st_wp Prims.unit | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.state",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | true | false | let write_wp: state -> st_wp unit =
| fun s _ p -> p ((), s) | false |
AlgHeap.fst | AlgHeap.modifies1 | val modifies1 (l: loc) (h0 h1: state) : Type0 | val modifies1 (l: loc) (h0 h1: state) : Type0 | let modifies1 (l:loc) (h0 h1 : state) : Type0 =
forall y. y <> l ==> Map.sel h0 y == Map.sel h1 y | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 414,
"start_col": 0,
"start_line": 413
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | l: AlgHeap.loc -> h0: AlgHeap.state -> h1: AlgHeap.state -> Type0 | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.loc",
"AlgHeap.state",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.eq2",
"Prims.int",
"FStar.Map.sel"
] | [] | false | false | false | true | true | let modifies1 (l: loc) (h0 h1: state) : Type0 =
| forall y. y <> l ==> Map.sel h0 y == Map.sel h1 y | false |
SolveThen.fst | SolveThen.f8 | val f8:int | val f8:int | let f8 : int = _ by (solve_then (fun () -> fib 8) compute) | {
"file_name": "examples/tactics/SolveThen.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 24,
"start_col": 0,
"start_line": 24
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SolveThen.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FS... | {
"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 | Prims.int | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let f8:int =
| FStar.Tactics.Effect.synth_by_tactic (fun _ -> (solve_then (fun () -> fib 8) compute)) | false |
AlgHeap.fst | AlgHeap.read_wp | val read_wp:st_wp state | val read_wp:st_wp state | let read_wp : st_wp state = fun s0 p -> p (s0, s0) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 232,
"start_col": 0,
"start_line": 232
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 | AlgHeap.st_wp AlgHeap.state | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.state",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | true | false | let read_wp:st_wp state =
| fun s0 p -> p (s0, s0) | false |
Vale.AES.X64.GCMdecryptOpt.fst | Vale.AES.X64.GCMdecryptOpt.va_lemma_Gcm_blocks_wrapped | val va_lemma_Gcm_blocks_wrapped : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> offset:int ->
auth_b:buffer128 -> abytes_b:buffer128 -> in128x6_b:buffer128 -> out128x6_b:buffer128 ->
in128_b:buffer128 -> out128_b:buffer128 -> inout_b:buffer128 -> iv_b:buffer128 ->
iv:supported_iv_LE -> scratch_b:buffer128 -... | val va_lemma_Gcm_blocks_wrapped : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> offset:int ->
auth_b:buffer128 -> abytes_b:buffer128 -> in128x6_b:buffer128 -> out128x6_b:buffer128 ->
in128_b:buffer128 -> out128_b:buffer128 -> inout_b:buffer128 -> iv_b:buffer128 ->
iv:supported_iv_LE -> scratch_b:buffer128 -... | let va_lemma_Gcm_blocks_wrapped va_b0 va_s0 alg offset auth_b abytes_b in128x6_b out128x6_b in128_b
out128_b inout_b iv_b iv scratch_b key round_keys keys_b hkeys_b expected_tag =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_mem_heaplet 5;
va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_... | {
"file_name": "obj/Vale.AES.X64.GCMdecryptOpt.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 1691,
"start_col": 0,
"start_line": 1598
} | module Vale.AES.X64.GCMdecryptOpt
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GCM
open Vale.AES.GHash_s
open Vale.AE... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Stack.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.In... | [
{
"abbrev": false,
"full_module": "Vale.Lib.Basic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.GCMencryptOpt",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
alg: Vale.AES.AES_common_s.algorithm ->
offset: Prims.int ->
auth_b: Vale.X64.Memory.buffer128 ->
abytes_b: Vale.X64.Memory.buffer128 ->
in128x6_b: Vale.X64.Memory.buffer128 ->
out128x6_b: Vale.X64.Memory.buffer128 ->
... | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.AES.AES_common_s.algorithm",
"Prims.int",
"Vale.X64.Memory.buffer128",
"Vale.AES.GCM_s.supported_iv_LE",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.quad32",
"Vale.X64.Memory.nat8",
"Vale.X64.QuickCodes.fuel",
"Prims... | [] | false | false | false | false | false | let va_lemma_Gcm_blocks_wrapped
va_b0
va_s0
alg
offset
auth_b
abytes_b
in128x6_b
out128x6_b
in128_b
out128_b
inout_b
iv_b
iv
scratch_b
key
round_keys
keys_b
hkeys_b
expected_tag
=
| let va_mods:va_mods_t =
[
va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_mem_heaplet 5; va_Mod_mem_heaplet 3;
va_Mod_mem_heaplet 2; va_Mod_mem_heaplet 1; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 8; va_Mod_xmm 7;
va_Mod_xmm 6; va_Mod... | false |
AlgHeap.fst | AlgHeap.bind_wp | val bind_wp (#a #b: _) (w: st_wp a) (wf: (a -> st_wp b)) : st_wp b | val bind_wp (#a #b: _) (w: st_wp a) (wf: (a -> st_wp b)) : st_wp b | let bind_wp #a #b (w : st_wp a) (wf : a -> st_wp b)
: st_wp b
= fun s0 p -> w s0 (fun (y, s1) -> wf y s1 p) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 229,
"start_col": 0,
"start_line": 227
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 | w: AlgHeap.st_wp a -> wf: (_: a -> AlgHeap.st_wp b) -> AlgHeap.st_wp b | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.st_wp",
"AlgHeap.state",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | true | false | let bind_wp #a #b (w: st_wp a) (wf: (a -> st_wp b)) : st_wp b =
| fun s0 p -> w s0 (fun (y, s1) -> wf y s1 p) | false |
AlgHeap.fst | AlgHeap.interp_as_wp | val interp_as_wp (#a: _) (t: rwtree a) : st_wp a | val interp_as_wp (#a: _) (t: rwtree a) : st_wp a | let rec interp_as_wp #a (t : rwtree a) : st_wp a =
match t with
| Return x -> return_wp x
| Op Read _ k ->
bind_wp read_wp (fun s -> interp_as_wp (k s))
| Op Write s k ->
bind_wp (write_wp s) (fun (o:unit) -> interp_as_wp (k o)) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 61,
"end_line": 244,
"start_col": 0,
"start_line": 238
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.rwtree a -> AlgHeap.st_wp a | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.rwtree",
"AlgHeap.return_wp",
"AlgHeap.op_inp",
"AlgHeap.Read",
"AlgHeap.op_out",
"AlgHeap.tree0",
"AlgHeap.bind_wp",
"AlgHeap.state",
"AlgHeap.read_wp",
"AlgHeap.interp_as_wp",
"AlgHeap.st_wp",
"AlgHeap.Write",
"Prims.unit",
"AlgHeap.write_wp"
] | [
"recursion"
] | false | false | false | true | false | let rec interp_as_wp #a (t: rwtree a) : st_wp a =
| match t with
| Return x -> return_wp x
| Op Read _ k -> bind_wp read_wp (fun s -> interp_as_wp (k s))
| Op Write s k -> bind_wp (write_wp s) (fun (o: unit) -> interp_as_wp (k o)) | false |
Vale.Inline.X64.Fadd_inline.fst | Vale.Inline.X64.Fadd_inline.fsub | val fsub
(out:u256)
(f1:u256)
(f2:u256)
: Stack unit
(requires fun h ->
adx_enabled /\ bmi2_enabled /\
B.live h f1 /\ B.live h f2 /\ B.live h out /\
(B.disjoint out f1 \/ out == f1) /\
(B.disjoint out f2 \/ out == f2) /\
(B.disjoint f1 f2 \/ f1 == f2))
(ensures fun h0 _ h1... | val fsub
(out:u256)
(f1:u256)
(f2:u256)
: Stack unit
(requires fun h ->
adx_enabled /\ bmi2_enabled /\
B.live h f1 /\ B.live h f2 /\ B.live h out /\
(B.disjoint out f1 \/ out == f1) /\
(B.disjoint out f2 \/ out == f2) /\
(B.disjoint f1 f2 \/ f1 == f2))
(ensures fun h0 _ h1... | let fsub out f1 f2
= DV.length_eq (get_downview out);
DV.length_eq (get_downview f1);
DV.length_eq (get_downview f2);
let (x, _) = lowstar_Fsub_normal_t out f1 f2 () in
() | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fadd_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 410,
"start_col": 0,
"start_line": 405
} | module Vale.Inline.X64.Fadd_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Va... | [
{
"abbrev": false,
"full_module": "Vale.AsLowStar.MemoryHelpers",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
... | {
"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 |
out: Vale.Inline.X64.Fadd_inline.u256 ->
f1: Vale.Inline.X64.Fadd_inline.u256 ->
f2: Vale.Inline.X64.Fadd_inline.u256
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Vale.Inline.X64.Fadd_inline.u256",
"FStar.UInt64.t",
"FStar.Ghost.erased",
"Vale.Interop.X64.as_lowstar_sig_ret",
"Prims.unit",
"Vale.Interop.X64.als_ret",
"Vale.Inline.X64.Fadd_inline.lowstar_Fsub_normal_t",
"LowStar.BufferView.Down.length_eq",
"FStar.UInt8.t",
"Vale.Interop.Types.get_downview",... | [] | false | true | false | false | false | let fsub out f1 f2 =
| DV.length_eq (get_downview out);
DV.length_eq (get_downview f1);
DV.length_eq (get_downview f2);
let x, _ = lowstar_Fsub_normal_t out f1 f2 () in
() | false |
AlgHeap.fst | AlgHeap.interp_rdwr_tree | val interp_rdwr_tree (#a: _) (t: tree a [Read; Write]) (s: state) : Tot (a & state) | val interp_rdwr_tree (#a: _) (t: tree a [Read; Write]) (s: state) : Tot (a & state) | let rec interp_rdwr_tree #a (t : tree a [Read;Write]) (s:state) : Tot (a & state) =
match t with
| Return x -> (x, s)
| Op Read _ k ->
interp_rdwr_tree (k s) s
| Op Write s k ->
interp_rdwr_tree (k ()) s | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 252,
"start_col": 0,
"start_line": 246
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.tree a [AlgHeap.Read; AlgHeap.Write] -> s: AlgHeap.state -> a * AlgHeap.state | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.tree",
"Prims.Cons",
"AlgHeap.op",
"AlgHeap.Read",
"AlgHeap.Write",
"Prims.Nil",
"AlgHeap.state",
"FStar.Pervasives.Native.Mktuple2",
"AlgHeap.op_inp",
"AlgHeap.op_out",
"AlgHeap.tree0",
"AlgHeap.interp_rdwr_tree",
"FStar.Pervasives.Native.tuple2"
] | [
"recursion"
] | false | false | false | true | false | let rec interp_rdwr_tree #a (t: tree a [Read; Write]) (s: state) : Tot (a & state) =
| match t with
| Return x -> (x, s)
| Op Read _ k -> interp_rdwr_tree (k s) s
| Op Write s k -> interp_rdwr_tree (k ()) s | false |
AlgHeap.fst | AlgHeap.bind2 | val bind2
(a b: Type)
(wp_v: st_wp a)
(wp_f: (a -> st_wp b))
(v: repr a wp_v)
(f: (x: a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f) | val bind2
(a b: Type)
(wp_v: st_wp a)
(wp_f: (a -> st_wp b))
(v: repr a wp_v)
(f: (x: a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f) | let bind2 (a : Type) (b : Type)
(wp_v : st_wp a) (wp_f: a -> st_wp b)
(v : repr a wp_v) (f : (x:a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f) =
interp_bind v f wp_v wp_f;
tbind v f | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 352,
"start_col": 0,
"start_line": 347
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 ->
wp_v: AlgHeap.st_wp a ->
wp_f: (_: a -> AlgHeap.st_wp b) ->
v: AlgHeap.repr a wp_v ->
f: (x: a -> AlgHeap.repr b (wp_f x))
-> AlgHeap.repr b (AlgHeap.bind_wp wp_v wp_f) | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.st_wp",
"AlgHeap.repr",
"AlgHeap.tbind",
"Prims.unit",
"AlgHeap.interp_bind",
"AlgHeap.bind_wp"
] | [] | false | false | false | false | false | let bind2
(a b: Type)
(wp_v: st_wp a)
(wp_f: (a -> st_wp b))
(v: repr a wp_v)
(f: (x: a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f) =
| interp_bind v f wp_v wp_f;
tbind v f | false |
AlgHeap.fst | AlgHeap.lift_pure_wp | val lift_pure_wp (#a: Type) (wp: pure_wp a) : st_wp a | val lift_pure_wp (#a: Type) (wp: pure_wp a) : st_wp a | let lift_pure_wp (#a:Type) (wp : pure_wp a) : st_wp a =
elim_pure_wp_monotonicity wp;
fun s0 p -> wp (fun x -> p (x, s0)) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 388,
"start_col": 0,
"start_line": 386
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | wp: Prims.pure_wp a -> AlgHeap.st_wp a | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_wp",
"AlgHeap.state",
"FStar.Pervasives.Native.tuple2",
"Prims.l_True",
"FStar.Pervasives.Native.Mktuple2",
"Prims.pure_pre",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"AlgHeap.st_wp"
] | [] | false | false | false | true | false | let lift_pure_wp (#a: Type) (wp: pure_wp a) : st_wp a =
| elim_pure_wp_monotonicity wp;
fun s0 p -> wp (fun x -> p (x, s0)) | false |
AlgHeap.fst | AlgHeap.lift_pure_algwp | val lift_pure_algwp (a: Type) (wp: _) (f: (unit -> PURE a wp))
: Pure (repr a (lift_pure_wp wp)) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) | val lift_pure_algwp (a: Type) (wp: _) (f: (unit -> PURE a wp))
: Pure (repr a (lift_pure_wp wp)) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) | let lift_pure_algwp (a:Type) wp (f:unit -> PURE a wp)
: Pure (repr a (lift_pure_wp wp)) // can't call f() here, so lift its wp instead
(requires (wp (fun _ -> True)))
(ensures (fun _ -> True))
= let v : a = elim_pure f (fun _ -> True) in
FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp; // ne... | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 398,
"start_col": 0,
"start_line": 390
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | a: Type -> wp: Prims.pure_wp a -> f: (_: Prims.unit -> Prims.PURE a)
-> Prims.Pure (AlgHeap.repr a (AlgHeap.lift_pure_wp wp)) | Prims.Pure | [] | [] | [
"Prims.pure_wp",
"Prims.unit",
"AlgHeap.Return",
"FStar.Pervasives.assert_norm",
"AlgHeap.stronger",
"AlgHeap.lift_pure_wp",
"AlgHeap.return_wp",
"Prims._assert",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"FStar.Monotonic.Pure.elim_pure",
"Prims.l_Tru... | [] | false | false | false | false | false | let lift_pure_algwp (a: Type) wp (f: (unit -> PURE a wp))
: Pure (repr a (lift_pure_wp wp)) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) =
| let v:a = elim_pure f (fun _ -> True) in
FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
assert (forall p. wp p ==> p v);
assert_norm (stronger (lift_pure_wp wp) (return_wp v));
Return v | false |
AlgHeap.fst | AlgHeap.interp_monotonic | val interp_monotonic (#a: _) (c: rwtree a) : Lemma (wp_is_monotonic (interp_as_wp c)) | val interp_monotonic (#a: _) (c: rwtree a) : Lemma (wp_is_monotonic (interp_as_wp c)) | let rec interp_monotonic #a (c:rwtree a) : Lemma (wp_is_monotonic (interp_as_wp c)) =
match c with
| Return x -> ()
| Op Read _ k ->
let aux (x:state) : Lemma (wp_is_monotonic (interp_as_wp (k x))) =
interp_monotonic (k x)
in
Classical.forall_intro aux;
bind_preserves_mon read_wp (fun x -> i... | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 291,
"start_col": 0,
"start_line": 277
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.rwtree a
-> FStar.Pervasives.Lemma (ensures AlgHeap.wp_is_monotonic (AlgHeap.interp_as_wp c)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"AlgHeap.rwtree",
"AlgHeap.op_inp",
"AlgHeap.Read",
"AlgHeap.op_out",
"AlgHeap.tree0",
"AlgHeap.bind_preserves_mon",
"AlgHeap.state",
"AlgHeap.read_wp",
"AlgHeap.interp_as_wp",
"AlgHeap.st_wp",
"Prims.unit",
"FStar.Classical.forall_intro",
"AlgHeap.wp_is_monotonic",
"Prims.l_True",
"Prim... | [
"recursion"
] | false | false | true | false | false | let rec interp_monotonic #a (c: rwtree a) : Lemma (wp_is_monotonic (interp_as_wp c)) =
| match c with
| Return x -> ()
| Op Read _ k ->
let aux (x: state) : Lemma (wp_is_monotonic (interp_as_wp (k x))) = interp_monotonic (k x) in
Classical.forall_intro aux;
bind_preserves_mon read_wp (fun x -> interp_as_wp (k x))
| Op Write s k ->
let aux (x: unit) : Lemma (wp_is_monotonic (interp_as_wp (k x))) = i... | false |
AlgHeap.fst | AlgHeap.interp_bind | val interp_bind (#a #b:Type)
(c : rwtree a) (f : a -> rwtree b)
(w1 : st_wp a) (w2 : a -> st_wp b)
: Lemma (requires w1 <<= interp_as_wp c /\ (forall x. w2 x <<= interp_as_wp (f x)))
(ensures bind_wp w1 w2 `stronger` interp_as_wp (tbind c f)) | val interp_bind (#a #b:Type)
(c : rwtree a) (f : a -> rwtree b)
(w1 : st_wp a) (w2 : a -> st_wp b)
: Lemma (requires w1 <<= interp_as_wp c /\ (forall x. w2 x <<= interp_as_wp (f x)))
(ensures bind_wp w1 w2 `stronger` interp_as_wp (tbind c f)) | let interp_bind #a #b c f w1 w2 =
let aux (p: (b & state -> Type0)) (s0:state) : Lemma (bind_wp w1 w2 s0 p ==> interp_as_wp (tbind c f) s0 p) =
calc (==>) {
bind_wp w1 w2 s0 p;
==> {}
w1 s0 (fun (y, s1) -> w2 y s1 p);
==> { (* hyp *)}
interp_as_wp c s0 (fun (y, s1) -> w2 y s1 p);
... | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 338,
"start_col": 0,
"start_line": 324
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.rwtree a ->
f: (_: a -> AlgHeap.rwtree b) ->
w1: AlgHeap.st_wp a ->
w2: (_: a -> AlgHeap.st_wp b)
-> FStar.Pervasives.Lemma
(requires
w1 <<= AlgHeap.interp_as_wp c /\ (forall (x: a). w2 x <<= AlgHeap.interp_as_wp (f x)))
(ensures AlgHeap.stronger (AlgHeap.bind_wp w1 w2)... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"AlgHeap.rwtree",
"AlgHeap.st_wp",
"FStar.Classical.forall_intro_2",
"FStar.Pervasives.Native.tuple2",
"AlgHeap.state",
"Prims.l_imp",
"AlgHeap.bind_wp",
"AlgHeap.interp_as_wp",
"AlgHeap.tbind",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar... | [] | false | false | true | false | false | let interp_bind #a #b c f w1 w2 =
| let aux (p: ((b & state) -> Type0)) (s0: state)
: Lemma (bind_wp w1 w2 s0 p ==> interp_as_wp (tbind c f) s0 p) =
calc ( ==> ) {
bind_wp w1 w2 s0 p;
( ==> ) { () }
w1 s0 (fun (y, s1) -> w2 y s1 p);
( ==> ) { () }
interp_as_wp c s0 (fun (y, s1) -> w2 y s1 p);
( ==> ) { interp_monotonic c }
... | false |
AlgHeap.fst | AlgHeap.put2 | val put2 (s: state) : AlgWP unit (write_wp s) | val put2 (s: state) : AlgWP unit (write_wp s) | let put2 (s:state) : AlgWP unit (write_wp s) =
AlgWP?.reflect (_put s) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 381,
"start_col": 0,
"start_line": 380
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.state -> AlgHeap.AlgWP Prims.unit | AlgHeap.AlgWP | [] | [] | [
"AlgHeap.state",
"AlgHeap._put",
"Prims.unit",
"AlgHeap.write_wp"
] | [] | false | true | false | false | false | let put2 (s: state) : AlgWP unit (write_wp s) =
| AlgWP?.reflect (_put s) | false |
AlgHeap.fst | AlgHeap.return2 | val return2 (a: Type) (x: a) : repr a (return_wp x) | val return2 (a: Type) (x: a) : repr a (return_wp x) | let return2 (a:Type) (x:a) : repr a (return_wp x) =
interp_ret x;
Return x | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 345,
"start_col": 0,
"start_line": 343
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 -> AlgHeap.repr a (AlgHeap.return_wp x) | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.Return",
"Prims.unit",
"AlgHeap.interp_ret",
"AlgHeap.repr",
"AlgHeap.return_wp"
] | [] | false | false | false | false | false | let return2 (a: Type) (x: a) : repr a (return_wp x) =
| interp_ret x;
Return x | false |
AlgHeap.fst | AlgHeap.upd | val upd (r: loc) (v: int) : AlgWP unit (fun h0 p -> p ((), Map.upd h0 r v)) | val upd (r: loc) (v: int) : AlgWP unit (fun h0 p -> p ((), Map.upd h0 r v)) | let upd (r:loc) (v:int) : AlgWP unit (fun h0 p -> p ((), Map.upd h0 r v)) =
let h = get2 () in
put2 (Map.upd h r v) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 408,
"start_col": 0,
"start_line": 406
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | r: AlgHeap.loc -> v: Prims.int -> AlgHeap.AlgWP Prims.unit | AlgHeap.AlgWP | [] | [] | [
"AlgHeap.loc",
"Prims.int",
"AlgHeap.put2",
"FStar.Map.upd",
"Prims.unit",
"AlgHeap.state",
"AlgHeap.get2",
"FStar.Map.t",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | true | false | false | false | let upd (r: loc) (v: int) : AlgWP unit (fun h0 p -> p ((), Map.upd h0 r v)) =
| let h = get2 () in
put2 (Map.upd h r v) | false |
AlgHeap.fst | AlgHeap.subcomp2 | val subcomp2 (a: Type) (w1 w2: st_wp a) (f: repr a w1)
: Pure (repr a w2) (requires w2 `stronger` w1) (ensures fun _ -> True) | val subcomp2 (a: Type) (w1 w2: st_wp a) (f: repr a w1)
: Pure (repr a w2) (requires w2 `stronger` w1) (ensures fun _ -> True) | let subcomp2 (a:Type) (w1 w2: st_wp a)
(f : repr a w1)
: Pure (repr a w2)
(requires w2 `stronger` w1)
(ensures fun _ -> True)
= f | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 359,
"start_col": 0,
"start_line": 354
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 -> w1: AlgHeap.st_wp a -> w2: AlgHeap.st_wp a -> f: AlgHeap.repr a w1
-> Prims.Pure (AlgHeap.repr a w2) | Prims.Pure | [] | [] | [
"AlgHeap.st_wp",
"AlgHeap.repr",
"AlgHeap.stronger",
"Prims.l_True"
] | [] | false | false | false | false | false | let subcomp2 (a: Type) (w1 w2: st_wp a) (f: repr a w1)
: Pure (repr a w2) (requires w2 `stronger` w1) (ensures fun _ -> True) =
| f | false |
AlgHeap.fst | AlgHeap.swap | val swap (l1 l2: loc)
: AlgPP unit
(fun _ -> l1 <> l2)
(fun h0 _ h1 ->
modifies [l1; l2] h0 h1 /\ Map.sel h1 l1 == Map.sel h0 l2 /\
Map.sel h1 l2 == Map.sel h0 l1) | val swap (l1 l2: loc)
: AlgPP unit
(fun _ -> l1 <> l2)
(fun h0 _ h1 ->
modifies [l1; l2] h0 h1 /\ Map.sel h1 l1 == Map.sel h0 l2 /\
Map.sel h1 l2 == Map.sel h0 l1) | let swap (l1 l2 : loc) : AlgPP unit (fun _ -> l1 <> l2)
(fun h0 _ h1 ->
modifies [l1;l2] h0 h1 /\
Map.sel h1 l1 == Map.sel h0 l2 /\
Map.sel h1 l2 == Map.sel h0 l1)
... | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 9,
"end_line": 434,
"start_col": 0,
"start_line": 426
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | l1: AlgHeap.loc -> l2: AlgHeap.loc -> AlgHeap.AlgPP Prims.unit | AlgHeap.AlgPP | [] | [] | [
"AlgHeap.loc",
"AlgHeap.op_Colon_Equals",
"Prims.unit",
"Prims.int",
"AlgHeap.op_Bang",
"AlgHeap.state",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.l_and",
"AlgHeap.modifies",
"Prims.Cons",
"Prims.Nil",
"Prims.eq2",
"FStar.Map.sel"
] | [] | false | true | false | false | false | let swap (l1 l2: loc)
: AlgPP unit
(fun _ -> l1 <> l2)
(fun h0 _ h1 ->
modifies [l1; l2] h0 h1 /\ Map.sel h1 l1 == Map.sel h0 l2 /\
Map.sel h1 l2 == Map.sel h0 l1) =
| let r = !l2 in
l2 := !l1;
l1 := r | false |
Hacl.Bignum.ModInv.fst | Hacl.Bignum.ModInv.mk_bn_mod_inv_prime | val mk_bn_mod_inv_prime:
#t:limb_t
-> len:BN.meta_len t
-> bn_mod_exp:BE.bn_mod_exp_st t len ->
bn_mod_inv_prime_st t len | val mk_bn_mod_inv_prime:
#t:limb_t
-> len:BN.meta_len t
-> bn_mod_exp:BE.bn_mod_exp_st t len ->
bn_mod_inv_prime_st t len | let mk_bn_mod_inv_prime #t len bn_mod_exp nBits n a res =
let h0 = ST.get () in
push_frame ();
let n2 = create len (uint #t #SEC 0) in
bn_mod_inv_prime_n2 #t len n n2;
SD.bn_eval_bound (as_seq h0 n) (v len);
bn_mod_exp nBits n a (size (bits t) *! len) n2 res;
let h1 = ST.get () in
assert (bn_v h1 res =... | {
"file_name": "code/bignum/Hacl.Bignum.ModInv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 135,
"start_col": 0,
"start_line": 124
} | module Hacl.Bignum.ModInv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module S = Hacl.Spec.Bignum.ModInv
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BM = Hacl.Bignum.Montgomery... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.ModInv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Montgomery.f... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"ab... | {
"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: Hacl.Bignum.meta_len t -> bn_mod_exp: Hacl.Bignum.Exponentiation.bn_mod_exp_st t len
-> Hacl.Bignum.ModInv.bn_mod_inv_prime_st t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Exponentiation.bn_mod_exp_st",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Spec.Bignum.ModInv.mod_inv_prime_lemma",
"Hacl.Bignum.Definitions.bn_v",
"Prims._asse... | [] | false | false | false | false | false | let mk_bn_mod_inv_prime #t len bn_mod_exp nBits n a res =
| let h0 = ST.get () in
push_frame ();
let n2 = create len (uint #t #SEC 0) in
bn_mod_inv_prime_n2 #t len n n2;
SD.bn_eval_bound (as_seq h0 n) (v len);
bn_mod_exp nBits n a (size (bits t) *! len) n2 res;
let h1 = ST.get () in
assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2));
S.mod_inv_prim... | false |
AlgHeap.fst | AlgHeap.get2 | val get2: Prims.unit -> AlgWP state read_wp | val get2: Prims.unit -> AlgWP state read_wp | let get2 () : AlgWP state read_wp =
AlgWP?.reflect _get | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 378,
"start_col": 0,
"start_line": 377
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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 | _: Prims.unit -> AlgHeap.AlgWP AlgHeap.state | AlgHeap.AlgWP | [] | [] | [
"Prims.unit",
"AlgHeap._get",
"AlgHeap.state",
"AlgHeap.read_wp"
] | [] | false | true | false | false | false | let get2 () : AlgWP state read_wp =
| AlgWP?.reflect _get | false |
AlgHeap.fst | AlgHeap.addx | val addx (l: loc) (x: int)
: AlgPP unit
(fun _ -> True)
(fun h0 _ h1 -> modifies1 l h0 h1 /\ (Map.sel h1 l == x + Map.sel h0 l)) | val addx (l: loc) (x: int)
: AlgPP unit
(fun _ -> True)
(fun h0 _ h1 -> modifies1 l h0 h1 /\ (Map.sel h1 l == x + Map.sel h0 l)) | let addx (l:loc) (x:int) : AlgPP unit (fun _ -> True) (fun h0 _ h1 -> modifies1 l h0 h1
/\ (Map.sel h1 l == x + Map.sel h0 l)) =
l := !l + x | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 424,
"start_col": 0,
"start_line": 422
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | l: AlgHeap.loc -> x: Prims.int -> AlgHeap.AlgPP Prims.unit | AlgHeap.AlgPP | [] | [] | [
"AlgHeap.loc",
"Prims.int",
"AlgHeap.op_Colon_Equals",
"Prims.unit",
"Prims.op_Addition",
"AlgHeap.op_Bang",
"AlgHeap.state",
"Prims.l_True",
"Prims.l_and",
"AlgHeap.modifies1",
"Prims.eq2",
"FStar.Map.sel"
] | [] | false | true | false | false | false | let addx (l: loc) (x: int)
: AlgPP unit
(fun _ -> True)
(fun h0 _ h1 -> modifies1 l h0 h1 /\ (Map.sel h1 l == x + Map.sel h0 l)) =
| l := !l + x | false |
AlgHeap.fst | AlgHeap.sel | val sel (r: loc) : AlgWP int (fun h0 p -> p (Map.sel h0 r, h0)) | val sel (r: loc) : AlgWP int (fun h0 p -> p (Map.sel h0 r, h0)) | let sel (r:loc) : AlgWP int (fun h0 p -> p (Map.sel h0 r, h0)) =
let h = get2 () in
Map.sel h r | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 404,
"start_col": 0,
"start_line": 402
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | r: AlgHeap.loc -> AlgHeap.AlgWP Prims.int | AlgHeap.AlgWP | [] | [] | [
"AlgHeap.loc",
"FStar.Map.sel",
"Prims.int",
"AlgHeap.state",
"AlgHeap.get2",
"FStar.Map.t",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | true | false | false | false | let sel (r: loc) : AlgWP int (fun h0 p -> p (Map.sel h0 r, h0)) =
| let h = get2 () in
Map.sel h r | false |
AlgHeap.fst | AlgHeap.soundnessPP | val soundnessPP (#a #pre #post: _) (t: (unit -> AlgPP a pre post)) (s0: state{pre s0})
: r: (a & state){post s0 (fst r) (snd r)} | val soundnessPP (#a #pre #post: _) (t: (unit -> AlgPP a pre post)) (s0: state{pre s0})
: r: (a & state){post s0 (fst r) (snd r)} | let soundnessPP #a #pre #post (t : unit -> AlgPP a pre post)
: s0:state{pre s0} -> r:(a & state){post s0 (fst r) (snd r)}
= fun s0 -> reify (soundness #a #(fun h0 p -> pre h0 /\ (forall y h1. post h0 y h1 ==> p (y, h1))) t s0)
(fun r -> post s0 (fst r) (snd r))
() | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 464,
"start_col": 0,
"start_line": 460
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | t: (_: Prims.unit -> AlgHeap.AlgPP a) -> s0: AlgHeap.state{pre s0}
-> r:
(a * AlgHeap.state) {post s0 (FStar.Pervasives.Native.fst r) (FStar.Pervasives.Native.snd r)} | Prims.Tot | [
"total"
] | [] | [
"AlgHeap.state",
"Prims.unit",
"AlgHeap.soundness",
"FStar.Pervasives.Native.tuple2",
"Prims.logical",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.hide",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd"
] | [] | false | false | false | false | false | let soundnessPP #a #pre #post (t: (unit -> AlgPP a pre post))
(s0: state{pre s0}) : r: (a & state){post s0 (fst r) (snd r)} =
| fun s0 ->
reify (soundness #a #(fun h0 p -> pre h0 /\ (forall y h1. post h0 y h1 ==> p (y, h1))) t s0)
(fun r -> post s0 (fst r) (snd r))
() | false |
Hacl.Bignum.ModInv.fst | Hacl.Bignum.ModInv.mk_bn_mod_inv_prime_precomp | val mk_bn_mod_inv_prime_precomp:
#t:limb_t
-> len:BN.meta_len t
-> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len ->
bn_mod_inv_prime_precomp_st t len | val mk_bn_mod_inv_prime_precomp:
#t:limb_t
-> len:BN.meta_len t
-> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len ->
bn_mod_inv_prime_precomp_st t len | let mk_bn_mod_inv_prime_precomp #t len bn_mod_exp_precomp n mu r2 a res =
let h0 = ST.get () in
push_frame ();
let n2 = create len (uint #t #SEC 0) in
bn_mod_inv_prime_n2 #t len n n2;
SD.bn_eval_bound (as_seq h0 n) (v len);
bn_mod_exp_precomp n mu r2 a (size (bits t) *! len) n2 res;
let h1 = ST.get () in... | {
"file_name": "code/bignum/Hacl.Bignum.ModInv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 97,
"start_col": 0,
"start_line": 86
} | module Hacl.Bignum.ModInv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module S = Hacl.Spec.Bignum.ModInv
module BN = Hacl.Bignum
module BE = Hacl.Bignum.Exponentiation
module BM = Hacl.Bignum.Montgomery... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.ModInv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Montgomery.f... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"ab... | {
"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: Hacl.Bignum.meta_len t ->
bn_mod_exp_precomp: Hacl.Bignum.Exponentiation.bn_mod_exp_precomp_st t len
-> Hacl.Bignum.ModInv.bn_mod_inv_prime_precomp_st t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Exponentiation.bn_mod_exp_precomp_st",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Spec.Bignum.ModInv.mod_inv_prime_lemma",
"Hacl.Bignum.Definitions.bn_v... | [] | false | false | false | false | false | let mk_bn_mod_inv_prime_precomp #t len bn_mod_exp_precomp n mu r2 a res =
| let h0 = ST.get () in
push_frame ();
let n2 = create len (uint #t #SEC 0) in
bn_mod_inv_prime_n2 #t len n n2;
SD.bn_eval_bound (as_seq h0 n) (v len);
bn_mod_exp_precomp n mu r2 a (size (bits t) *! len) n2 res;
let h1 = ST.get () in
assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2));
S.mod_... | false |
AlgHeap.fst | AlgHeap.soundness_aux | val soundness_aux (#a #wp: _) (t: repr a wp)
: Tot (s0: state -> ID5.ID (a & state) (as_pure_wp (wp s0))) | val soundness_aux (#a #wp: _) (t: repr a wp)
: Tot (s0: state -> ID5.ID (a & state) (as_pure_wp (wp s0))) | let soundness_aux #a #wp (t:repr a wp)
: Tot (s0:state -> ID5.ID (a & state) (as_pure_wp (wp s0)))
= extract t;
interp_sem t | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 453,
"start_col": 0,
"start_line": 450
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | t: AlgHeap.repr a wp -> s0: AlgHeap.state -> ID5.ID (a * AlgHeap.state) | ID5.ID | [] | [] | [
"AlgHeap.st_wp",
"AlgHeap.repr",
"AlgHeap.interp_sem",
"Prims.unit",
"AlgHeap.extract",
"AlgHeap.state",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Pure.as_pure_wp"
] | [] | false | true | false | false | false | let soundness_aux #a #wp (t: repr a wp) : Tot (s0: state -> ID5.ID (a & state) (as_pure_wp (wp s0))) =
| extract t;
interp_sem t | false |
AlgHeap.fst | AlgHeap.interp_morph | val interp_morph (#a #b: _) (c: rwtree a) (f: (a -> rwtree b)) (p s0: _)
: Lemma
(interp_as_wp c s0 (fun (y, s1) -> interp_as_wp (f y) s1 p) == interp_as_wp (tbind c f) s0 p) | val interp_morph (#a #b: _) (c: rwtree a) (f: (a -> rwtree b)) (p s0: _)
: Lemma
(interp_as_wp c s0 (fun (y, s1) -> interp_as_wp (f y) s1 p) == interp_as_wp (tbind c f) s0 p) | let rec interp_morph #a #b (c : rwtree a) (f : a -> rwtree b) (p:_) (s0:_)
: Lemma (interp_as_wp c s0 (fun (y, s1) -> interp_as_wp (f y) s1 p) == interp_as_wp (tbind c f) s0 p)
= match c with
| Return x -> ()
| Op Read _ k ->
let aux (o:state) : Lemma (interp_as_wp (k o) s0 (fun (y, s1) -> interp_as_w... | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 317,
"start_col": 0,
"start_line": 299
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "Ghost"
},
{
"abbrev": true,
"full_module": "Latt... | {
"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: AlgHeap.rwtree a ->
f: (_: a -> AlgHeap.rwtree b) ->
p: (_: (b * AlgHeap.state) -> Type0) ->
s0: AlgHeap.state
-> FStar.Pervasives.Lemma
(ensures
AlgHeap.interp_as_wp c
s0
(fun _ ->
(let FStar.Pervasives.Native.Mktuple2 #_ #_ y s1 = _ in
AlgHeap.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"AlgHeap.rwtree",
"FStar.Pervasives.Native.tuple2",
"AlgHeap.state",
"AlgHeap.op_inp",
"AlgHeap.Read",
"AlgHeap.op_out",
"AlgHeap.tree0",
"FStar.Classical.forall_intro",
"Prims.eq2",
"AlgHeap.interp_as_wp",
"AlgHeap.tbind",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FS... | [
"recursion"
] | false | false | true | false | false | let rec interp_morph #a #b (c: rwtree a) (f: (a -> rwtree b)) (p: _) (s0: _)
: Lemma
(interp_as_wp c s0 (fun (y, s1) -> interp_as_wp (f y) s1 p) == interp_as_wp (tbind c f) s0 p) =
| match c with
| Return x -> ()
| Op Read _ k ->
let aux (o: state)
: Lemma
(interp_as_wp (k o) s0 (fun (y, s1) -> interp_as_wp (f y) s1 p) ==
interp_as_wp (tbind (k o) f) s0 p) =
interp_morph (k o) f p s0
in
Classical.forall_intro aux
| Op Write s k ->
let aux (o: unit)
: Lemma
... | false |
AlgHeap.fst | AlgHeap.soundness | val soundness (#a #wp: _) (t: (unit -> AlgWP a wp))
: Tot (s0: state -> ID5.ID (a & state) (as_pure_wp (wp s0))) | val soundness (#a #wp: _) (t: (unit -> AlgWP a wp))
: Tot (s0: state -> ID5.ID (a & state) (as_pure_wp (wp s0))) | let soundness #a #wp (t : unit -> AlgWP a wp)
: Tot (s0:state -> ID5.ID (a & state) (as_pure_wp (wp s0)))
= soundness_aux (reify (t ())) | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 457,
"start_col": 0,
"start_line": 455
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | t: (_: Prims.unit -> AlgHeap.AlgWP a) -> s0: AlgHeap.state -> ID5.ID (a * AlgHeap.state) | ID5.ID | [] | [] | [
"AlgHeap.st_wp",
"Prims.unit",
"AlgHeap.soundness_aux",
"AlgHeap.state",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Pure.as_pure_wp"
] | [] | false | true | false | false | false | let soundness #a #wp (t: (unit -> AlgWP a wp))
: Tot (s0: state -> ID5.ID (a & state) (as_pure_wp (wp s0))) =
| soundness_aux (reify (t ())) | false |
AlgHeap.fst | AlgHeap.interp_sem | val interp_sem (#a: _) (t: rwtree a) (s0: state)
: ID5.ID (a & state) (as_pure_wp (interp_as_wp t s0)) | val interp_sem (#a: _) (t: rwtree a) (s0: state)
: ID5.ID (a & state) (as_pure_wp (interp_as_wp t s0)) | let rec interp_sem #a (t : rwtree a) (s0:state)
: ID5.ID (a & state) (as_pure_wp (interp_as_wp t s0))
= match t with
| Return x -> (x, s0)
| Op Read i k ->
interp_sem (k s0) s0
| Op Write i k ->
interp_sem (k ()) i | {
"file_name": "examples/layeredeffects/AlgHeap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 443,
"start_col": 0,
"start_line": 436
} | module AlgHeap
(* Essentially a copy of AlgForAll but using a heap for the state *)
open FStar.Tactics.V2
open FStar.List.Tot
open FStar.Universe
module L = Lattice
module Ghost = FStar.Ghost
module Map = FStar.Map
module T = FStar.Tactics.V2
type loc = int
type state = Map.t loc int
type empty : Type u#aa =
type ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lattice.fst.checked",
"ID5.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked",
"FSta... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "Map"
},
{
"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 | t: AlgHeap.rwtree a -> s0: AlgHeap.state -> ID5.ID (a * AlgHeap.state) | ID5.ID | [] | [] | [
"AlgHeap.rwtree",
"AlgHeap.state",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"AlgHeap.op_inp",
"AlgHeap.Read",
"AlgHeap.op_out",
"AlgHeap.tree0",
"AlgHeap.interp_sem",
"AlgHeap.Write",
"FStar.Monotonic.Pure.as_pure_wp",
"AlgHeap.interp_as_wp"
] | [
"recursion"
] | false | true | false | false | false | let rec interp_sem #a (t: rwtree a) (s0: state)
: ID5.ID (a & state) (as_pure_wp (interp_as_wp t s0)) =
| match t with
| Return x -> (x, s0)
| Op Read i k -> interp_sem (k s0) s0
| Op Write i k -> interp_sem (k ()) i | false |
LowParse.SLow.BCVLI.fst | LowParse.SLow.BCVLI.size32_bounded_bcvli | val size32_bounded_bcvli (min: nat) (max: nat{min <= max})
: Tot (size32 (serialize_bounded_bcvli min max)) | val size32_bounded_bcvli (min: nat) (max: nat{min <= max})
: Tot (size32 (serialize_bounded_bcvli min max)) | let size32_bounded_bcvli
(min: nat)
(max: nat { min <= max })
: Tot (size32 (serialize_bounded_bcvli min max))
= fun x -> ((
[@inline_let]
let _ = serialize_bounded_bcvli_eq min max x in
size32_bcvli x
) <: (res: _ { size32_postcond (serialize_bounded_bcvli min max) x res })) | {
"file_name": "src/lowparse/LowParse.SLow.BCVLI.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 76,
"end_line": 147,
"start_col": 0,
"start_line": 139
} | module LowParse.SLow.BCVLI
include LowParse.Spec.BCVLI
include LowParse.SLow.Combinators // for make_total_constant_size_parser32
include LowParse.SLow.BoundedInt // for bounded_integer_le
module B32 = LowParse.Bytes32
module Seq = FStar.Seq
module U32 = FStar.UInt32
module Cast = FStar.Int.Cast
#push-options "--max_... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BCVLI.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.... | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | min: Prims.nat -> max: Prims.nat{min <= max}
-> LowParse.SLow.Base.size32 (LowParse.Spec.BCVLI.serialize_bounded_bcvli min max) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.SLow.BCVLI.size32_bcvli",
"Prims.unit",
"LowParse.Spec.BCVLI.serialize_bounded_bcvli_eq",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.BCVLI.parse_bounded_bcvli_kind"... | [] | false | false | false | false | false | let size32_bounded_bcvli (min: nat) (max: nat{min <= max})
: Tot (size32 (serialize_bounded_bcvli min max)) =
| fun x ->
(([@@ inline_let ]let _ = serialize_bounded_bcvli_eq min max x in
size32_bcvli x)
<:
(res: _{size32_postcond (serialize_bounded_bcvli min max) x res})) | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_from_bytes_le_f | val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:nat{i < len} ->
vec_t vt w | val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:nat{i < len} ->
vec_t vt w | let vecs_from_bytes_le_f vt w len b i =
vec_from_bytes_le vt w (LSeq.sub b (i * (numbytes vt * w)) (numbytes vt * w)) | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 16,
"start_col": 0,
"start_line": 15
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 |
vt: Lib.IntVector.v_inttype ->
w: Lib.IntVector.width ->
len: Prims.nat{len * (Lib.IntTypes.numbytes vt * w) <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (len * (Lib.IntTypes.numbytes vt * w)) ->
i: Prims.nat{i < len}
-> Lib.IntVector.vec_t vt w | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.op_LessThan",
"Lib.IntVector.vec_from_bytes_le",
"Lib.Sequence.su... | [] | false | false | false | false | false | let vecs_from_bytes_le_f vt w len b i =
| vec_from_bytes_le vt w (LSeq.sub b (i * (numbytes vt * w)) (numbytes vt * w)) | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_from_bytes_be | val vecs_from_bytes_be: vt:v_inttype -> w:width -> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w)) -> lseq (vec_t vt w) len | val vecs_from_bytes_be: vt:v_inttype -> w:width -> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w)) -> lseq (vec_t vt w) len | let vecs_from_bytes_be vt w len b =
LSeq.createi len (vecs_from_bytes_be_f vt w len b) | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 36,
"start_col": 0,
"start_line": 35
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 |
vt: Lib.IntVector.v_inttype ->
w: Lib.IntVector.width ->
len: Prims.nat{len * (Lib.IntTypes.numbytes vt * w) <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (len * (Lib.IntTypes.numbytes vt * w))
-> Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.Sequence.createi",
"Lib.IntVector.vec_t",
"Lib.IntVector.Serialize.... | [] | false | false | false | false | false | let vecs_from_bytes_be vt w len b =
| LSeq.createi len (vecs_from_bytes_be_f vt w len b) | false |
Vale.AES.X64.GCMdecryptOpt.fst | Vale.AES.X64.GCMdecryptOpt.va_wp_Gcm_blocks | val va_wp_Gcm_blocks
(alg: algorithm)
(offset: int)
(auth_b abytes_b in128x6_b out128x6_b in128_b out128_b inout_b iv_b scratch_b: buffer128)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_b hkeys_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
... | val va_wp_Gcm_blocks
(alg: algorithm)
(offset: int)
(auth_b abytes_b in128x6_b out128x6_b in128_b out128_b inout_b iv_b scratch_b: buffer128)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_b hkeys_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
... | let va_wp_Gcm_blocks (alg:algorithm) (offset:int) (auth_b:buffer128) (abytes_b:buffer128)
(in128x6_b:buffer128) (out128x6_b:buffer128) (in128_b:buffer128) (out128_b:buffer128)
(inout_b:buffer128) (iv_b:buffer128) (scratch_b:buffer128) (key:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (hkeys_b:buffer1... | {
"file_name": "obj/Vale.AES.X64.GCMdecryptOpt.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 1285,
"start_col": 0,
"start_line": 1120
} | module Vale.AES.X64.GCMdecryptOpt
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.AES.GCM
open Vale.AES.GHash_s
open Vale.AE... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Stack.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.In... | [
{
"abbrev": false,
"full_module": "Vale.Lib.Basic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.GCMencryptOpt",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
alg: Vale.AES.AES_common_s.algorithm ->
offset: Prims.int ->
auth_b: Vale.X64.Memory.buffer128 ->
abytes_b: Vale.X64.Memory.buffer128 ->
in128x6_b: Vale.X64.Memory.buffer128 ->
out128x6_b: Vale.X64.Memory.buffer128 ->
in128_b: Vale.X64.Memory.buffer128 ->
out128_b: Vale.X64.Memory.buffe... | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.AES_common_s.algorithm",
"Prims.int",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.quad32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Vale.X... | [] | false | false | false | true | true | let va_wp_Gcm_blocks
(alg: algorithm)
(offset: int)
(auth_b abytes_b in128x6_b out128x6_b in128_b out128_b inout_b iv_b scratch_b: buffer128)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_b hkeys_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
... | (va_get_ok va_s0 /\
(let abytes_ptr:Vale.X64.Memory.nat64 =
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + offset + 0) (va_get_stack va_s0)
in
let in128x6_ptr:Vale.X64.Memory.nat64 =
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + offset + 8) (va_get_stack va_s0)
in
let ... | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_from_bytes_le | val vecs_from_bytes_le: vt:v_inttype -> w:width -> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w)) -> lseq (vec_t vt w) len | val vecs_from_bytes_le: vt:v_inttype -> w:width -> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w)) -> lseq (vec_t vt w) len | let vecs_from_bytes_le vt w len b =
LSeq.createi len (vecs_from_bytes_le_f vt w len b) | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 19,
"start_col": 0,
"start_line": 18
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 |
vt: Lib.IntVector.v_inttype ->
w: Lib.IntVector.width ->
len: Prims.nat{len * (Lib.IntTypes.numbytes vt * w) <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (len * (Lib.IntTypes.numbytes vt * w))
-> Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.Sequence.createi",
"Lib.IntVector.vec_t",
"Lib.IntVector.Serialize.... | [] | false | false | false | false | false | let vecs_from_bytes_le vt w len b =
| LSeq.createi len (vecs_from_bytes_le_f vt w len b) | false |
Hacl.Frodo.KEM.fst | Hacl.Frodo.KEM.crypto_kem_keypair | val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a | val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a | let crypto_kem_keypair a gen_a pk sk =
Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk | {
"file_name": "code/frodo/Hacl.Frodo.KEM.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | module Hacl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Frodo.Random
module S = Spec.Frodo.KEM
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_fo... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Impl.Frodo.KEM.KeyGen.fst.c... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.Random",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Hacl.Frodo.KEM.crypto_kem_keypair_st a gen_a | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair",
"Lib.IntType... | [] | false | false | false | false | false | let crypto_kem_keypair a gen_a pk sk =
| Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk | false |
Hacl.Frodo.KEM.fst | Hacl.Frodo.KEM.crypto_kem_dec | val crypto_kem_dec: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_dec_st a gen_a | val crypto_kem_dec: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_dec_st a gen_a | let crypto_kem_dec a gen_a ss ct sk =
Hacl.Impl.Frodo.KEM.Decaps.crypto_kem_dec a gen_a ss ct sk | {
"file_name": "code/frodo/Hacl.Frodo.KEM.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 73,
"start_col": 0,
"start_line": 72
} | module Hacl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Frodo.Random
module S = Spec.Frodo.KEM
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_fo... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Impl.Frodo.KEM.KeyGen.fst.c... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.Random",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Hacl.Frodo.KEM.crypto_kem_dec_st a gen_a | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Impl.Frodo.KEM.... | [] | false | false | false | false | false | let crypto_kem_dec a gen_a ss ct sk =
| Hacl.Impl.Frodo.KEM.Decaps.crypto_kem_dec a gen_a ss ct sk | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_from_bytes_be_f | val vecs_from_bytes_be_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:nat{i < len} ->
vec_t vt w | val vecs_from_bytes_be_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:nat{i < len} ->
vec_t vt w | let vecs_from_bytes_be_f vt w len b i =
vec_from_bytes_be vt w (LSeq.sub b (i * (numbytes vt * w)) (numbytes vt * w)) | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 33,
"start_col": 0,
"start_line": 32
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 |
vt: Lib.IntVector.v_inttype ->
w: Lib.IntVector.width ->
len: Prims.nat{len * (Lib.IntTypes.numbytes vt * w) <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (len * (Lib.IntTypes.numbytes vt * w)) ->
i: Prims.nat{i < len}
-> Lib.IntVector.vec_t vt w | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.op_LessThan",
"Lib.IntVector.vec_from_bytes_be",
"Lib.Sequence.su... | [] | false | false | false | false | false | let vecs_from_bytes_be_f vt w len b i =
| vec_from_bytes_be vt w (LSeq.sub b (i * (numbytes vt * w)) (numbytes vt * w)) | false |
Hacl.Frodo.KEM.fst | Hacl.Frodo.KEM.crypto_kem_enc | val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a | val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a | let crypto_kem_enc a gen_a ct ss pk =
Hacl.Impl.Frodo.KEM.Encaps.crypto_kem_enc a gen_a ct ss pk | {
"file_name": "code/frodo/Hacl.Frodo.KEM.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 54,
"start_col": 0,
"start_line": 53
} | module Hacl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Frodo.Random
module S = Spec.Frodo.KEM
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_fo... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Impl.Frodo.KEM.KeyGen.fst.c... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.Random",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Hacl.Frodo.KEM.crypto_kem_enc_st a gen_a | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Hacl.Impl.Frodo.KEM.... | [] | false | false | false | false | false | let crypto_kem_enc a gen_a ct ss pk =
| Hacl.Impl.Frodo.KEM.Encaps.crypto_kem_enc a gen_a ct ss pk | false |
LowParse.SLow.BCVLI.fst | LowParse.SLow.BCVLI.serialize32_bounded_bcvli | val serialize32_bounded_bcvli (min: nat) (max: nat{min <= max})
: Tot (serializer32 (serialize_bounded_bcvli min max)) | val serialize32_bounded_bcvli (min: nat) (max: nat{min <= max})
: Tot (serializer32 (serialize_bounded_bcvli min max)) | let serialize32_bounded_bcvli
(min: nat)
(max: nat { min <= max })
: Tot (serializer32 (serialize_bounded_bcvli min max))
= fun x -> ((
[@inline_let]
let _ = serialize_bounded_bcvli_eq min max x in
serialize32_bcvli x
) <: (res: _ { serializer32_correct (serialize_bounded_bcvli min max) x res })) | {
"file_name": "src/lowparse/LowParse.SLow.BCVLI.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 81,
"end_line": 136,
"start_col": 0,
"start_line": 128
} | module LowParse.SLow.BCVLI
include LowParse.Spec.BCVLI
include LowParse.SLow.Combinators // for make_total_constant_size_parser32
include LowParse.SLow.BoundedInt // for bounded_integer_le
module B32 = LowParse.Bytes32
module Seq = FStar.Seq
module U32 = FStar.UInt32
module Cast = FStar.Int.Cast
#push-options "--max_... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BCVLI.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.... | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | min: Prims.nat -> max: Prims.nat{min <= max}
-> LowParse.SLow.Base.serializer32 (LowParse.Spec.BCVLI.serialize_bounded_bcvli min max) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.SLow.BCVLI.serialize32_bcvli",
"Prims.unit",
"LowParse.Spec.BCVLI.serialize_bounded_bcvli_eq",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.BCVLI.par... | [] | false | false | false | false | false | let serialize32_bounded_bcvli (min: nat) (max: nat{min <= max})
: Tot (serializer32 (serialize_bounded_bcvli min max)) =
| fun x ->
(([@@ inline_let ]let _ = serialize_bounded_bcvli_eq min max x in
serialize32_bcvli x)
<:
(res: _{serializer32_correct (serialize_bounded_bcvli min max) x res})) | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_to_bytes_le | val vecs_to_bytes_le: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> lseq uint8 (len * (numbytes vt * w)) | val vecs_to_bytes_le: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> lseq uint8 (len * (numbytes vt * w)) | let vecs_to_bytes_le #vt #w #len vl =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes vt * w) len len a_spec
(vecs_to_bytes_le_f #vt #w #len vl) () in
o | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 57,
"start_col": 0,
"start_line": 53
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 | vl: Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len
-> Lib.Sequence.lseq Lib.IntTypes.uint8 (len * (Lib.IntTypes.numbytes vt * w)) | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Prims.int",
... | [] | false | false | false | false | false | let vecs_to_bytes_le #vt #w #len vl =
| let a_spec (i: nat{i <= len}) = unit in
let _, o =
generate_blocks (numbytes vt * w) len len a_spec (vecs_to_bytes_le_f #vt #w #len vl) ()
in
o | false |
Hacl.Impl.RSAPSS.fst | Hacl.Impl.RSAPSS.rsapss_sign_ | val rsapss_sign_:
#t:limb_t
-> ke:BE.exp t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:modBits_t t ->
rsapss_sign_st1 t ke a modBits | val rsapss_sign_:
#t:limb_t
-> ke:BE.exp t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:modBits_t t ->
rsapss_sign_st1 t ke a modBits | let rsapss_sign_ #t ke a modBits eBits dBits skey saltLen salt msgLen msg sgnt =
push_frame ();
[@inline_let] let bits : size_pos = bits t in
let nLen = blocks modBits (size bits) in
let m = create nLen (uint #t 0) in
rsapss_sign_msg_to_bn a modBits saltLen salt msgLen msg m;
let eq_b = rsapss_sign_compute_... | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 224,
"start_col": 0,
"start_line": 216
} | module Hacl.Impl.RSAPSS
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module Hash = Spec.Agile.Hash
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module SD = Hacl.Spec.Bignum.Definitions
... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.Keys",
"short_module": "RK"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.MGF",
"short_module": "RM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.Padding",
"short_module": "RP"
},
{
"abbrev": true... | {
"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 |
ke: Hacl.Bignum.Exponentiation.exp t ->
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Hacl.Impl.RSAPSS.modBits_t t
-> Hacl.Impl.RSAPSS.rsapss_sign_st1 t ke a modBits | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Hacl.Impl.RSAPSS.modBits_t",
"Lib.IntTypes.size_t",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"H... | [] | false | false | false | false | false | let rsapss_sign_ #t ke a modBits eBits dBits skey saltLen salt msgLen msg sgnt =
| push_frame ();
[@@ inline_let ]let bits:size_pos = bits t in
let nLen = blocks modBits (size bits) in
let m = create nLen (uint #t 0) in
rsapss_sign_msg_to_bn a modBits saltLen salt msgLen msg m;
let eq_b = rsapss_sign_compute_sgnt ke modBits eBits dBits skey m sgnt in
pop_frame ();
eq_b | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_to_bytes_le_f | val vecs_to_bytes_le_f:
#vt:v_inttype
-> #w:width
-> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes vt * w) | val vecs_to_bytes_le_f:
#vt:v_inttype
-> #w:width
-> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes vt * w) | let vecs_to_bytes_le_f #vt #w #len vl i () =
(), vec_to_bytes_le vl.[i] | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 51,
"start_col": 0,
"start_line": 50
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 | vl: Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len -> i: Prims.nat{i < len} -> _: Prims.unit
-> Prims.unit * Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes vt * w) | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Prims.op_LessThan",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
... | [] | false | false | false | false | false | let vecs_to_bytes_le_f #vt #w #len vl i () =
| (), vec_to_bytes_le vl.[ i ] | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_to_bytes_be_f | val vecs_to_bytes_be_f:
#vt:v_inttype
-> #w:width
-> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes vt * w) | val vecs_to_bytes_be_f:
#vt:v_inttype
-> #w:width
-> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes vt * w) | let vecs_to_bytes_be_f #vt #w #len vl i () =
(), vec_to_bytes_be vl.[i] | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 74,
"start_col": 0,
"start_line": 73
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 | vl: Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len -> i: Prims.nat{i < len} -> _: Prims.unit
-> Prims.unit * Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes vt * w) | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Prims.op_LessThan",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
... | [] | false | false | false | false | false | let vecs_to_bytes_be_f #vt #w #len vl i () =
| (), vec_to_bytes_be vl.[ i ] | false |
Hacl.Frodo.KEM.fst | Hacl.Frodo.KEM.crypto_kem_keypair_st | val crypto_kem_keypair_st : a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Type0 | let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) =
pk:lbytes (crypto_publickeybytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> Stack uint32
(requires fun h ->
live h pk /\ live h sk /\
disjoint pk sk /\ disjoint state pk /\ disjoint state sk)
(ensures ... | {
"file_name": "code/frodo/Hacl.Frodo.KEM.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 85,
"end_line": 28,
"start_col": 0,
"start_line": 20
} | module Hacl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Frodo.Random
module S = Spec.Frodo.KEM
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Impl.Frodo.KEM.KeyGen.fst.c... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.Random",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Lib.IntTypes.uint32",
"FStar.Monotonic.HyperStack.mem",
"P... | [] | false | false | false | false | true | let crypto_kem_keypair_st (a: FP.frodo_alg) (gen_a: FP.frodo_gen_a{is_supported gen_a}) =
| pk: lbytes (crypto_publickeybytes a) -> sk: lbytes (crypto_secretkeybytes a)
-> Stack uint32
(requires
fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk)
(ensures
fun h0 r h1 ->
modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\
... | false | |
Hacl.Impl.RSAPSS.fst | Hacl.Impl.RSAPSS.rsapss_skey_sign | val rsapss_skey_sign:
#t:limb_t
-> ke:BE.exp t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:modBits_t t
-> rsapss_load_skey:RK.rsapss_load_skey_st t ke modBits
-> rsapss_sign:rsapss_sign_st t ke a modBits ->
rsapss_skey_sign_st t ke a modBits | val rsapss_skey_sign:
#t:limb_t
-> ke:BE.exp t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:modBits_t t
-> rsapss_load_skey:RK.rsapss_load_skey_st t ke modBits
-> rsapss_sign:rsapss_sign_st t ke a modBits ->
rsapss_skey_sign_st t ke a modBits | let rsapss_skey_sign #t ke a modBits rsapss_load_skey rsapss_sign eBits dBits nb eb db saltLen salt msgLen msg sgnt =
[@inline_let] let bits = size (bits t) in
let h0 = ST.get () in
push_frame ();
let skey = create (2ul *! blocks modBits bits +! blocks eBits bits +! blocks dBits bits) (uint #t 0) in
let b = r... | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 571,
"start_col": 0,
"start_line": 553
} | module Hacl.Impl.RSAPSS
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module Hash = Spec.Agile.Hash
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module SD = Hacl.Spec.Bignum.Definitions
... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.Keys",
"short_module": "RK"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.MGF",
"short_module": "RM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.RSAPSS.Padding",
"short_module": "RP"
},
{
"abbrev": true... | {
"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 |
ke: Hacl.Bignum.Exponentiation.exp t ->
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Hacl.Impl.RSAPSS.modBits_t t ->
rsapss_load_skey: Hacl.Impl.RSAPSS.Keys.rsapss_load_skey_st t ke modBits ->
rsapss_sign: Hacl.Impl.RSAPSS.rsapss_sign_st t ke a modBits
-> Hacl.Im... | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Hacl.Impl.RSAPSS.modBits_t",
"Hacl.Impl.RSAPSS.Keys.rsapss_load_skey_st",
"Hacl.Impl.RSAPSS.rsapss_sign_st",
"Lib.IntTypes.size_t",
"Hacl.Spec.RSAPSS... | [] | false | false | false | false | false | let rsapss_skey_sign
#t
ke
a
modBits
rsapss_load_skey
rsapss_sign
eBits
dBits
nb
eb
db
saltLen
salt
msgLen
msg
sgnt
=
| [@@ inline_let ]let bits = size (bits t) in
let h0 = ST.get () in
push_frame ();
let skey =
create (2ul *! blocks modBits bits +! blocks eBits bits +! blocks dBits bits) (uint #t 0)
in
let b = rsapss_load_skey eBits dBits nb eb db skey in
LS.rsapss_load_skey_lemma #t
(v modBits)
(v eBits)
(v dBits)
(as_seq h0... | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.name_to_string | val name_to_string (f:R.name) : string | val name_to_string (f:R.name) : string | let name_to_string (f:R.name) = String.concat "." f | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 51,
"end_line": 32,
"start_col": 0,
"start_line": 32
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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: FStar.Stubs.Reflection.Types.name -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.name",
"FStar.String.concat",
"Prims.string"
] | [] | false | false | false | true | false | let name_to_string (f: R.name) =
| String.concat "." f | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_to_bytes_be | val vecs_to_bytes_be: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> lseq uint8 (len * (numbytes vt * w)) | val vecs_to_bytes_be: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> lseq uint8 (len * (numbytes vt * w)) | let vecs_to_bytes_be #vt #w #len vl =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes vt * w) len len a_spec
(vecs_to_bytes_be_f #vt #w #len vl) () in
o | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 80,
"start_col": 0,
"start_line": 76
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 | vl: Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len
-> Lib.Sequence.lseq Lib.IntTypes.uint8 (len * (Lib.IntTypes.numbytes vt * w)) | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Prims.int",
... | [] | false | false | false | false | false | let vecs_to_bytes_be #vt #w #len vl =
| let a_spec (i: nat{i <= len}) = unit in
let _, o =
generate_blocks (numbytes vt * w) len len a_spec (vecs_to_bytes_be_f #vt #w #len vl) ()
in
o | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.univ_to_string | val univ_to_string (u:universe) : string | val univ_to_string (u:universe) : string | let univ_to_string u = sprintf "u#%s" (universe_to_string 0 u) | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 62,
"end_line": 56,
"start_col": 0,
"start_line": 56
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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 | u14: Pulse.Syntax.Base.universe -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Pulse.Syntax.Base.universe",
"FStar.Printf.sprintf",
"Pulse.Syntax.Printer.universe_to_string",
"Prims.string"
] | [] | false | false | false | true | false | let univ_to_string u =
| sprintf "u#%s" (universe_to_string 0 u) | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.dbg_printing | val dbg_printing:bool | val dbg_printing:bool | let dbg_printing : bool = true | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 30,
"end_line": 34,
"start_col": 0,
"start_line": 34
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"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 | Prims.bool | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let dbg_printing:bool =
| true | false |
Hacl.Frodo.KEM.fst | Hacl.Frodo.KEM.crypto_kem_enc_st | val crypto_kem_enc_st : a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Type0 | let crypto_kem_enc_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) =
ct:lbytes (crypto_ciphertextbytes a)
-> ss:lbytes (crypto_bytes a)
-> pk:lbytes (crypto_publickeybytes a)
-> Stack uint32
(requires fun h ->
live h ct /\ live h ss /\ live h pk /\
disjoint ct ss /\ disjoint ct ... | {
"file_name": "code/frodo/Hacl.Frodo.KEM.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 96,
"end_line": 48,
"start_col": 0,
"start_line": 38
} | module Hacl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Frodo.Random
module S = Spec.Frodo.KEM
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_fo... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Impl.Frodo.KEM.KeyGen.fst.c... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.Random",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Lib.IntTypes.uint32"... | [] | false | false | false | false | true | let crypto_kem_enc_st (a: FP.frodo_alg) (gen_a: FP.frodo_gen_a{is_supported gen_a}) =
|
ct: lbytes (crypto_ciphertextbytes a) ->
ss: lbytes (crypto_bytes a) ->
pk: lbytes (crypto_publickeybytes a)
-> Stack uint32
(requires
fun h ->
live h ct /\ live h ss /\ live h pk /\ disjoint ct ss /\ disjoint ct pk /\ disjoint ss pk /\
disjoint state ct /\ disjoint stat... | false | |
LowParse.SLow.BCVLI.fst | LowParse.SLow.BCVLI.serialize32_bcvli | val serialize32_bcvli:serializer32 serialize_bcvli | val serialize32_bcvli:serializer32 serialize_bcvli | let serialize32_bcvli
: serializer32 serialize_bcvli
= fun x -> ((
[@inline_let] let _ = serialize_bcvli_eq x in
let c1 : bounded_integer 1 =
if x `U32.lt` 253ul
then x
else if x `U32.lt` 65536ul
then 253ul
else 254ul
in
let s1 = serialize32_bounded_integer_le_1 c1 in
i... | {
"file_name": "src/lowparse/LowParse.SLow.BCVLI.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 71,
"end_line": 61,
"start_col": 0,
"start_line": 44
} | module LowParse.SLow.BCVLI
include LowParse.Spec.BCVLI
include LowParse.SLow.Combinators // for make_total_constant_size_parser32
include LowParse.SLow.BoundedInt // for bounded_integer_le
module B32 = LowParse.Bytes32
module Seq = FStar.Seq
module U32 = FStar.UInt32
module Cast = FStar.Int.Cast
#push-options "--max_... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BCVLI.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.... | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | LowParse.SLow.Base.serializer32 LowParse.Spec.BCVLI.serialize_bcvli | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"FStar.UInt32.lt",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.op_Equality",
"FStar.Bytes.append",
"LowParse.SLow.BoundedInt.serialize32_bounded_integer_le_2",
"LowParse.SLow.BoundedInt.serialize32_bounded_integer_le_4",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.Base.seri... | [] | false | false | false | true | false | let serialize32_bcvli:serializer32 serialize_bcvli =
| fun x ->
(([@@ inline_let ]let _ = serialize_bcvli_eq x in
let c1:bounded_integer 1 =
if x `U32.lt` 253ul then x else if x `U32.lt` 65536ul then 253ul else 254ul
in
let s1 = serialize32_bounded_integer_le_1 c1 in
if c1 `U32.lt` 253ul
then s1
else
if c1 = 253ul
... | false |
LowParse.SLow.BCVLI.fst | LowParse.SLow.BCVLI.size32_bcvli | val size32_bcvli:size32 serialize_bcvli | val size32_bcvli:size32 serialize_bcvli | let size32_bcvli
: size32 serialize_bcvli
= fun x -> ((
[@inline_let] let _ = serialize_bcvli_eq x in
if x `U32.lt` 253ul
then 1ul
else if x `U32.lt` 65536ul
then 3ul
else 5ul
) <: (res: _ { size32_postcond serialize_bcvli x res } )) | {
"file_name": "src/lowparse/LowParse.SLow.BCVLI.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 59,
"end_line": 72,
"start_col": 0,
"start_line": 63
} | module LowParse.SLow.BCVLI
include LowParse.Spec.BCVLI
include LowParse.SLow.Combinators // for make_total_constant_size_parser32
include LowParse.SLow.BoundedInt // for bounded_integer_le
module B32 = LowParse.Bytes32
module Seq = FStar.Seq
module U32 = FStar.UInt32
module Cast = FStar.Int.Cast
#push-options "--max_... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BCVLI.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.... | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | LowParse.SLow.Base.size32 LowParse.Spec.BCVLI.serialize_bcvli | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"FStar.UInt32.lt",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.BCVLI.parse_bcvli_kind",
"LowParse.Spec.BCVLI.parse_bcvli",
"LowParse.Spec.BCVLI.serialize_bcvli",
"Prims.unit",
"LowParse.Spec.BCVLI.serialize_bcvli_eq"
] | [] | false | false | false | true | false | let size32_bcvli:size32 serialize_bcvli =
| fun x ->
(([@@ inline_let ]let _ = serialize_bcvli_eq x in
if x `U32.lt` 253ul then 1ul else if x `U32.lt` 65536ul then 3ul else 5ul)
<:
(res: _{size32_postcond serialize_bcvli x res})) | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.indent | val indent : level: Prims.string -> Prims.string | let indent (level:string) = level ^ "\t" | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 61,
"start_col": 0,
"start_line": 61
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"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 | level: Prims.string -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.op_Hat"
] | [] | false | false | false | true | false | let indent (level: string) =
| level ^ "\t" | false | |
Hacl.Impl.RSAPSS.Padding.fst | Hacl.Impl.RSAPSS.Padding.salt_len_t | val salt_len_t : a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | let salt_len_t (a:Hash.fixed_len_alg) =
saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Padding.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 137,
"end_line": 27,
"start_col": 0,
"start_line": 26
} | module Hacl.Impl.RSAPSS.Padding
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.RSAPSS.MGF
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Hash = Spec.Agile.Hash
module S = Spec.RSAPSS
module BD = Hacl.Bignum.Definitions
#reset-opti... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"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 | a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.fixed_len_alg",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Hacl.Impl.RSAPSS.Padding.less_th... | [] | false | false | false | true | true | let salt_len_t (a: Hash.fixed_len_alg) =
| saltLen:
size_t
{ 8 + Hash.hash_length a + v saltLen <= max_size_t /\
(8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a } | false | |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.term_to_string | val term_to_string (t:term) : T.Tac string | val term_to_string (t:term) : T.Tac string | let term_to_string t = term_to_string' "" t | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 43,
"end_line": 126,
"start_col": 0,
"start_line": 126
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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: Pulse.Syntax.Base.term -> FStar.Tactics.Effect.Tac Prims.string | FStar.Tactics.Effect.Tac | [] | [] | [
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Printer.term_to_string'",
"Prims.string"
] | [] | false | true | false | false | false | let term_to_string t =
| term_to_string' "" t | false |
Hacl.Impl.RSAPSS.Padding.fst | Hacl.Impl.RSAPSS.Padding.less_than_max_input_length | val less_than_max_input_length : l: Prims.int -> a: Spec.Hash.Definitions.hash_alg -> Prims.bool | let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Padding.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 23,
"start_col": 0,
"start_line": 23
} | module Hacl.Impl.RSAPSS.Padding
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.RSAPSS.MGF
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Hash = Spec.Agile.Hash
module S = Spec.RSAPSS
module BD = Hacl.Bignum.Definitions
#reset-opti... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"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 | l: Prims.int -> a: Spec.Hash.Definitions.hash_alg -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.less_than_max_input_length"
] | [] | false | false | false | true | false | let less_than_max_input_length =
| Spec.Hash.Definitions.less_than_max_input_length | false | |
Hacl.Impl.RSAPSS.Padding.fst | Hacl.Impl.RSAPSS.Padding.msg_len_t | val msg_len_t : a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | let msg_len_t (a:Hash.fixed_len_alg) =
msgLen:size_t{v msgLen `less_than_max_input_length` a} | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Padding.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 31,
"start_col": 0,
"start_line": 30
} | module Hacl.Impl.RSAPSS.Padding
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.RSAPSS.MGF
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Hash = Spec.Agile.Hash
module S = Spec.RSAPSS
module BD = Hacl.Bignum.Definitions
#reset-opti... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"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 | a: Spec.Hash.Definitions.fixed_len_alg -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.fixed_len_alg",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Hacl.Impl.RSAPSS.Padding.less_than_max_input_length",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB"
] | [] | false | false | false | true | true | let msg_len_t (a: Hash.fixed_len_alg) =
| msgLen: size_t{(v msgLen) `less_than_max_input_length` a} | false | |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.binder_to_string | val binder_to_string (b:binder) : T.Tac string | val binder_to_string (b:binder) : T.Tac string | let binder_to_string (b:binder)
: T.Tac string
= sprintf "%s%s:%s"
(match T.unseal b.binder_attrs with
| [] -> ""
| l -> sprintf "[@@@ %s] " (String.concat ";" (T.map (term_to_string' "") l)))
(T.unseal b.binder_ppname.name)
(term_to_string b.binder_ty) | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 175,
"start_col": 0,
"start_line": 168
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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: Pulse.Syntax.Base.binder -> FStar.Tactics.Effect.Tac Prims.string | FStar.Tactics.Effect.Tac | [] | [] | [
"Pulse.Syntax.Base.binder",
"Prims.string",
"FStar.Printf.sprintf",
"Prims.list",
"Pulse.Syntax.Base.term",
"FStar.String.concat",
"FStar.Tactics.Util.map",
"Pulse.Syntax.Printer.term_to_string'",
"FStar.Tactics.Unseal.unseal",
"Pulse.Syntax.Base.__proj__Mkbinder__item__binder_attrs",
"Pulse.Syn... | [] | false | true | false | false | false | let binder_to_string (b: binder) : T.Tac string =
| sprintf "%s%s:%s"
(match T.unseal b.binder_attrs with
| [] -> ""
| l -> sprintf "[@@@ %s] " (String.concat ";" (T.map (term_to_string' "") l)))
(T.unseal b.binder_ppname.name)
(term_to_string b.binder_ty) | false |
Hacl.Frodo.KEM.fst | Hacl.Frodo.KEM.crypto_kem_dec_st | val crypto_kem_dec_st : a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Type0 | let crypto_kem_dec_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) =
ss:lbytes (crypto_bytes a)
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> Stack uint32
(requires fun h ->
live h ss /\ live h ct /\ live h sk /\
disjoint ss ct /\ disjoint ss ... | {
"file_name": "code/frodo/Hacl.Frodo.KEM.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 67,
"start_col": 0,
"start_line": 58
} | module Hacl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Frodo.Random
module S = Spec.Frodo.KEM
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_fo... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Impl.Frodo.KEM.KeyGen.fst.c... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.Random",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Lib.IntTypes.uint32"... | [] | false | false | false | false | true | let crypto_kem_dec_st (a: FP.frodo_alg) (gen_a: FP.frodo_gen_a{is_supported gen_a}) =
|
ss: lbytes (crypto_bytes a) ->
ct: lbytes (crypto_ciphertextbytes a) ->
sk: lbytes (crypto_secretkeybytes a)
-> Stack uint32
(requires
fun h ->
live h ss /\ live h ct /\ live h sk /\ disjoint ss ct /\ disjoint ss sk /\ disjoint ct sk)
(ensures
fun h0 r h1 ->
... | false | |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.term_list_to_string | val term_list_to_string (sep:string) (t:list term): T.Tac string | val term_list_to_string (sep:string) (t:list term): T.Tac string | let term_list_to_string (sep:string) (t:list term)
: T.Tac string
= String.concat sep (T.map term_to_string t) | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 46,
"end_line": 227,
"start_col": 0,
"start_line": 225
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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 | sep: Prims.string -> t: Prims.list Pulse.Syntax.Base.term -> FStar.Tactics.Effect.Tac Prims.string | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.string",
"Prims.list",
"Pulse.Syntax.Base.term",
"FStar.String.concat",
"FStar.Tactics.Util.map",
"Pulse.Syntax.Printer.term_to_string"
] | [] | false | true | false | false | false | let term_list_to_string (sep: string) (t: list term) : T.Tac string =
| String.concat sep (T.map term_to_string t) | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.st_term_to_string | val st_term_to_string (t:st_term) : T.Tac string | val st_term_to_string (t:st_term) : T.Tac string | let st_term_to_string t = st_term_to_string' "" t | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 49,
"end_line": 432,
"start_col": 0,
"start_line": 432
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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: Pulse.Syntax.Base.st_term -> FStar.Tactics.Effect.Tac Prims.string | FStar.Tactics.Effect.Tac | [] | [] | [
"Pulse.Syntax.Base.st_term",
"Pulse.Syntax.Printer.st_term_to_string'",
"Prims.string"
] | [] | false | true | false | false | false | let st_term_to_string t =
| st_term_to_string' "" t | false |
LowParse.SLow.BCVLI.fst | LowParse.SLow.BCVLI.parse32_bounded_bcvli | val parse32_bounded_bcvli
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max})
(max32: U32.t{U32.v max32 == max})
: Tot (parser32 (parse_bounded_bcvli min max)) | val parse32_bounded_bcvli
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max})
(max32: U32.t{U32.v max32 == max})
: Tot (parser32 (parse_bounded_bcvli min max)) | let parse32_bounded_bcvli
(min: nat)
(min32: U32.t { U32.v min32 == min })
(max: nat { min <= max })
(max32: U32.t { U32.v max32 == max })
: Tot (parser32 (parse_bounded_bcvli min max))
= fun input -> ((
[@inline_let]
let _ = parse_bounded_bcvli_eq min max (B32.reveal input) in
[@inline_let]
let... | {
"file_name": "src/lowparse/LowParse.SLow.BCVLI.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 77,
"end_line": 125,
"start_col": 0,
"start_line": 75
} | module LowParse.SLow.BCVLI
include LowParse.Spec.BCVLI
include LowParse.SLow.Combinators // for make_total_constant_size_parser32
include LowParse.SLow.BoundedInt // for bounded_integer_le
module B32 = LowParse.Bytes32
module Seq = FStar.Seq
module U32 = FStar.UInt32
module Cast = FStar.Int.Cast
#push-options "--max_... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BCVLI.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.... | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
min: Prims.nat ->
min32: FStar.UInt32.t{FStar.UInt32.v min32 == min} ->
max: Prims.nat{min <= max} ->
max32: FStar.UInt32.t{FStar.UInt32.v max32 == max}
-> LowParse.SLow.Base.parser32 (LowParse.Spec.BCVLI.parse_bounded_bcvli min max) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.BoundedInt.parse32_bounded_integ... | [] | false | false | false | false | false | let parse32_bounded_bcvli
(min: nat)
(min32: U32.t{U32.v min32 == min})
(max: nat{min <= max})
(max32: U32.t{U32.v max32 == max})
: Tot (parser32 (parse_bounded_bcvli min max)) =
| fun input ->
(([@@ inline_let ]let _ = parse_bounded_bcvli_eq min max (B32.reveal input) in
[@@ inline_let ]let _ = parse_bcvli_eq (B32.reveal input) in
match parse32_bounded_integer_le_1 input with
| None -> None
| Some (x32, consumed_x) ->
if x32 `U32.lt` 253ul && min32 `U32.lte` x32... | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.index_vecs_to_bytes_be | val index_vecs_to_bytes_be: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> i:nat{i < len * (numbytes vt * w)} ->
Lemma ((vecs_to_bytes_be #vt #w #len vl).[i] == (vec_to_bytes_be vl.[i / (numbytes vt * w)]).[i % (numbytes vt * w)]) | val index_vecs_to_bytes_be: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> i:nat{i < len * (numbytes vt * w)} ->
Lemma ((vecs_to_bytes_be #vt #w #len vl).[i] == (vec_to_bytes_be vl.[i / (numbytes vt * w)]).[i % (numbytes vt * w)]) | let index_vecs_to_bytes_be #vt #w #len vl i =
index_generate_blocks (numbytes vt * w) len len
(vecs_to_bytes_be_f #vt #w #len vl) i | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 84,
"start_col": 0,
"start_line": 82
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 |
vl: Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len ->
i: Prims.nat{i < len * (Lib.IntTypes.numbytes vt * w)}
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntVector.Serialize.vecs_to_bytes_be vl).[ i ] ==
(Lib.IntVector.vec_to_bytes_be vl.[ i / (Lib.IntTypes.numbytes vt * w) ]).[ i %
(Lib... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Prims.op_LessThan",
"Lib.Sequence.index_generate_blocks",
"Lib.IntType... | [] | true | false | true | false | false | let index_vecs_to_bytes_be #vt #w #len vl i =
| index_generate_blocks (numbytes vt * w) len len (vecs_to_bytes_be_f #vt #w #len vl) i | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.decl_to_string | val decl_to_string (d:decl) : T.Tac string | val decl_to_string (d:decl) : T.Tac string | let decl_to_string (d:decl) : T.Tac string =
match d.d with
| FnDecl {id; isrec; bs; body} ->
"fn " ^ (if isrec then "rec " else "") ^
fst (R.inspect_ident id) ^ " " ^
String.concat " " (T.map (fun (_, b, _) -> binder_to_string b) bs) ^
" { " ^ st_term_to_string body ^ "}" | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 42,
"end_line": 538,
"start_col": 0,
"start_line": 532
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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 | d: Pulse.Syntax.Base.decl -> FStar.Tactics.Effect.Tac Prims.string | FStar.Tactics.Effect.Tac | [] | [] | [
"Pulse.Syntax.Base.decl",
"Pulse.Syntax.Base.__proj__Mkdecl__item__d",
"FStar.Stubs.Reflection.Types.ident",
"Prims.bool",
"Prims.list",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.option",
"Pulse.Syntax.Base.qualifier",
"Pulse.Syntax.Base.binder",
"Pulse.Syntax.Base.bv",
"Pulse.S... | [] | false | true | false | false | false | let decl_to_string (d: decl) : T.Tac string =
| match d.d with
| FnDecl { id = id ; isrec = isrec ; bs = bs ; body = body } ->
"fn " ^
(if isrec then "rec " else "") ^
fst (R.inspect_ident id) ^
" " ^
String.concat " " (T.map (fun (_, b, _) -> binder_to_string b) bs) ^
" { " ^ st_term_to_string body ^ "}" | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_load_be | val vecs_load_be:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer (vec_t vt w) len
-> i:lbuffer uint8 (len *! (size (numbytes vt) *! size w)) ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modif... | val vecs_load_be:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer (vec_t vt w) len
-> i:lbuffer uint8 (len *! (size (numbytes vt) *! size w)) ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modif... | let vecs_load_be #vt #w #len o i =
let h0 = ST.get () in
fill h0 len o
(fun h -> vecs_from_bytes_be_f vt w (v len) (as_seq h i))
(fun j ->
let h = ST.get () in
let bj = sub i (j *! (size (numbytes vt) *! size w)) (size (numbytes vt) *! size w) in
let r = vec_load_be vt w bj in
as_seq_gsub h i (j... | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 112,
"start_col": 0,
"start_line": 101
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Lib.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
o: Lib.Buffer.lbuffer (Lib.IntVector.vec_t vt w) len ->
i:
Lib.Buffer.lbuffer Lib.IntTypes.uint8
(len *! (Lib.IntTypes.size (Lib.IntTypes.numbytes vt) *! Lib.IntTypes.size w))
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntVector.vec_t",
... | [] | false | true | false | false | false | let vecs_load_be #vt #w #len o i =
| let h0 = ST.get () in
fill h0
len
o
(fun h -> vecs_from_bytes_be_f vt w (v len) (as_seq h i))
(fun j ->
let h = ST.get () in
let bj = sub i (j *! (size (numbytes vt) *! size w)) (size (numbytes vt) *! size w) in
let r = vec_load_be vt w bj in
as_seq_gsub h i (j *! (size (numbytes vt) *! ... | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.tot_or_ghost_to_string | val tot_or_ghost_to_string (eff:T.tot_or_ghost) : string | val tot_or_ghost_to_string (eff:T.tot_or_ghost) : string | let tot_or_ghost_to_string = function
| T.E_Total -> "total"
| T.E_Ghost -> "ghost" | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 24,
"end_line": 29,
"start_col": 0,
"start_line": 27
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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 | eff: FStar.Stubs.TypeChecker.Core.tot_or_ghost -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.TypeChecker.Core.tot_or_ghost",
"Prims.string"
] | [] | false | false | false | true | false | let tot_or_ghost_to_string =
| function
| T.E_Total -> "total"
| T.E_Ghost -> "ghost" | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_store_be | val vecs_store_be:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer uint8 (len *! (size (numbytes vt) *! size w))
-> i:lbuffer (vec_t vt w) len ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modi... | val vecs_store_be:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer uint8 (len *! (size (numbytes vt) *! size w))
-> i:lbuffer (vec_t vt w) len ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modi... | let vecs_store_be #vt #w #len o i =
let h0 = ST.get () in
[@ inline_let]
let a_spec (i:nat{i <= v len}) = unit in
fill_blocks h0 (size (numbytes vt) *! size w) len o a_spec
(fun _ _ -> ())
(fun _ -> LowStar.Buffer.loc_none)
(fun h -> vecs_to_bytes_be_f (as_seq h i))
(fun j -> vec_store_be (sub ... | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 78,
"end_line": 142,
"start_col": 0,
"start_line": 131
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Lib.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
o:
Lib.Buffer.lbuffer Lib.IntTypes.uint8
(len *! (Lib.IntTypes.size (Lib.IntTypes.numbytes vt) *! Lib.IntTypes.size w)) ->
i: Lib.Buffer.lbuffer (Lib.IntVector.vec_t vt w) len
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"... | [] | false | true | false | false | false | let vecs_store_be #vt #w #len o i =
| let h0 = ST.get () in
[@@ inline_let ]let a_spec (i: nat{i <= v len}) = unit in
fill_blocks h0
(size (numbytes vt) *! size w)
len
o
a_spec
(fun _ _ -> ())
(fun _ -> LowStar.Buffer.loc_none)
(fun h -> vecs_to_bytes_be_f (as_seq h i))
(fun j ->
vec_store_be (sub o (j *! (size (numbytes vt) *! size w... | false |
LowParse.SLow.BCVLI.fst | LowParse.SLow.BCVLI.parse32_bcvli | val parse32_bcvli:parser32 parse_bcvli | val parse32_bcvli:parser32 parse_bcvli | let parse32_bcvli
: parser32 parse_bcvli
= fun input -> ((
[@inline_let] let _ =
parse_bcvli_eq (B32.reveal input)
in
match parse32_bounded_integer_le_1 input with
| None -> None
| Some (x32, consumed_x) ->
if x32 `U32.lt` 253ul
then Some (x32, consumed_x)
else
let in... | {
"file_name": "src/lowparse/LowParse.SLow.BCVLI.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 60,
"end_line": 40,
"start_col": 0,
"start_line": 13
} | module LowParse.SLow.BCVLI
include LowParse.Spec.BCVLI
include LowParse.SLow.Combinators // for make_total_constant_size_parser32
include LowParse.SLow.BoundedInt // for bounded_integer_le
module B32 = LowParse.Bytes32
module Seq = FStar.Seq
module U32 = FStar.UInt32
module Cast = FStar.Int.Cast
#push-options "--max_... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BCVLI.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"LowParse.SLow.BoundedInt.fsti.checked",
"LowParse.Bytes32.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.... | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "LowP... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | LowParse.SLow.Base.parser32 LowParse.Spec.BCVLI.parse_bcvli | Prims.Tot | [
"total"
] | [] | [
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.BoundedInt.parse32_bounded_integer_le_1",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"LowParse.Spec.BoundedInt.bounded_integer",
"FStar.UInt32.lt",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Native.Some",
"FSt... | [] | false | false | false | true | false | let parse32_bcvli:parser32 parse_bcvli =
| fun input ->
(([@@ inline_let ]let _ = parse_bcvli_eq (B32.reveal input) in
match parse32_bounded_integer_le_1 input with
| None -> None
| Some (x32, consumed_x) ->
if x32 `U32.lt` 253ul
then Some (x32, consumed_x)
else
let input' = B32.slice input consumed_x (B32.l... | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.qual_to_string | val qual_to_string (q:option qualifier) : string | val qual_to_string (q:option qualifier) : string | let qual_to_string = function
| None -> ""
| Some Implicit -> "#" | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 24,
"end_line": 59,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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 | q: FStar.Pervasives.Native.option Pulse.Syntax.Base.qualifier -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.option",
"Pulse.Syntax.Base.qualifier",
"Prims.string"
] | [] | false | false | false | true | false | let qual_to_string =
| function
| None -> ""
| Some Implicit -> "#" | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.index_vecs_to_bytes_le | val index_vecs_to_bytes_le: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> i:nat{i < len * (numbytes vt * w)} ->
Lemma ((vecs_to_bytes_le #vt #w #len vl).[i] == (vec_to_bytes_le vl.[i / (numbytes vt * w)]).[i % (numbytes vt * w)]) | val index_vecs_to_bytes_le: #vt:v_inttype -> #w:width -> #len:nat{len * (numbytes vt * w) <= max_size_t}
-> vl:lseq (vec_t vt w) len -> i:nat{i < len * (numbytes vt * w)} ->
Lemma ((vecs_to_bytes_le #vt #w #len vl).[i] == (vec_to_bytes_le vl.[i / (numbytes vt * w)]).[i % (numbytes vt * w)]) | let index_vecs_to_bytes_le #vt #w #len vl i =
index_generate_blocks (numbytes vt * w) len len
(vecs_to_bytes_le_f #vt #w #len vl) i | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 61,
"start_col": 0,
"start_line": 59
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"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 |
vl: Lib.Sequence.lseq (Lib.IntVector.vec_t vt w) len ->
i: Prims.nat{i < len * (Lib.IntTypes.numbytes vt * w)}
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntVector.Serialize.vecs_to_bytes_le vl).[ i ] ==
(Lib.IntVector.vec_to_bytes_le vl.[ i / (Lib.IntTypes.numbytes vt * w) ]).[ i %
(Lib... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Prims.op_LessThan",
"Lib.Sequence.index_generate_blocks",
"Lib.IntType... | [] | true | false | true | false | false | let index_vecs_to_bytes_le #vt #w #len vl i =
| index_generate_blocks (numbytes vt * w) len len (vecs_to_bytes_le_f #vt #w #len vl) i | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_load_le | val vecs_load_le:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer (vec_t vt w) len
-> i:lbuffer uint8 (len *! (size (numbytes vt) *! size w)) ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modif... | val vecs_load_le:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer (vec_t vt w) len
-> i:lbuffer uint8 (len *! (size (numbytes vt) *! size w)) ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modif... | let vecs_load_le #vt #w #len o i =
let h0 = ST.get () in
fill h0 len o
(fun h -> vecs_from_bytes_le_f vt w (v len) (as_seq h i))
(fun j ->
let h = ST.get () in
let bj = sub i (j *! (size (numbytes vt) *! size w)) (size (numbytes vt) *! size w) in
let r = vec_load_le vt w bj in
as_seq_gsub h i (j... | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 98,
"start_col": 0,
"start_line": 87
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Lib.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
o: Lib.Buffer.lbuffer (Lib.IntVector.vec_t vt w) len ->
i:
Lib.Buffer.lbuffer Lib.IntTypes.uint8
(len *! (Lib.IntTypes.size (Lib.IntTypes.numbytes vt) *! Lib.IntTypes.size w))
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntVector.vec_t",
... | [] | false | true | false | false | false | let vecs_load_le #vt #w #len o i =
| let h0 = ST.get () in
fill h0
len
o
(fun h -> vecs_from_bytes_le_f vt w (v len) (as_seq h i))
(fun j ->
let h = ST.get () in
let bj = sub i (j *! (size (numbytes vt) *! size w)) (size (numbytes vt) *! size w) in
let r = vec_load_le vt w bj in
as_seq_gsub h i (j *! (size (numbytes vt) *! ... | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_4 | val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\
LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\
as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime)
(ensures f... | val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\
LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\
as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime)
(ensures f... | let point_add_4 x3 y3 z3 t1 t2 =
fmul_by_b_coeff z3 t2;
fsub x3 y3 z3;
fdouble z3 x3;
fadd x3 x3 z3;
fsub z3 t1 x3;
fadd x3 t1 x3;
fmul_by_b_coeff y3 y3 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 163,
"start_col": 0,
"start_line": 156
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
x3: Hacl.Impl.P256.Bignum.felem ->
y3: Hacl.Impl.P256.Bignum.felem ->
z3: Hacl.Impl.P256.Bignum.felem ->
t1: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Field.fmul_by_b_coeff",
"Prims.unit",
"Hacl.Impl.P256.Field.fadd",
"Hacl.Impl.P256.Field.fsub",
"Hacl.Impl.P256.Field.fdouble"
] | [] | false | true | false | false | false | let point_add_4 x3 y3 z3 t1 t2 =
| fmul_by_b_coeff z3 t2;
fsub x3 y3 z3;
fdouble z3 x3;
fadd x3 x3 z3;
fsub z3 t1 x3;
fadd x3 t1 x3;
fmul_by_b_coeff y3 y3 | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_5 | val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\
live h t0 /\ live h t1 /\ live h t2 /\
LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\
as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\
as_n... | val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\
live h t0 /\ live h t1 /\ live h t2 /\
LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\
as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\
as_n... | let point_add_5 x3 y3 z3 t0 t1 t2 =
fdouble t1 t2;
fadd t2 t1 t2;
fsub y3 y3 t2;
fsub y3 y3 t0;
fdouble t1 y3 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 192,
"start_col": 0,
"start_line": 187
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
x3: Hacl.Impl.P256.Bignum.felem ->
y3: Hacl.Impl.P256.Bignum.felem ->
z3: Hacl.Impl.P256.Bignum.felem ->
t0: Hacl.Impl.P256.Bignum.felem ->
t1: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Field.fdouble",
"Prims.unit",
"Hacl.Impl.P256.Field.fsub",
"Hacl.Impl.P256.Field.fadd"
] | [] | false | true | false | false | false | let point_add_5 x3 y3 z3 t0 t1 t2 =
| fdouble t1 t2;
fadd t2 t1 t2;
fsub y3 y3 t2;
fsub y3 y3 t0;
fdouble t1 y3 | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.universe_to_string | val universe_to_string (n: nat) (u: universe) : Tot string (decreases u) | val universe_to_string (n: nat) (u: universe) : Tot string (decreases u) | let rec universe_to_string (n:nat) (u:universe)
: Tot string (decreases u) =
let open R in
match inspect_universe u with
| Uv_Unk -> "_"
| Uv_Zero -> sprintf "%d" n
| Uv_Succ u -> universe_to_string (n + 1) u
| Uv_BVar x -> if n = 0 then sprintf "%d" x else sprintf "(%d + %d)" x n
| Uv_Max us ->
le... | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 25,
"end_line": 54,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"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 | n: Prims.nat -> u12: Pulse.Syntax.Base.universe -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"Prims.nat",
"Pulse.Syntax.Base.universe",
"FStar.Stubs.Reflection.V2.Builtins.inspect_universe",
"FStar.Printf.sprintf",
"FStar.Stubs.Reflection.Types.universe",
"Pulse.Syntax.Printer.universe_to_string",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.string",
"FS... | [
"recursion"
] | false | false | false | true | false | let rec universe_to_string (n: nat) (u: universe) : Tot string (decreases u) =
| let open R in
match inspect_universe u with
| Uv_Unk -> "_"
| Uv_Zero -> sprintf "%d" n
| Uv_Succ u -> universe_to_string (n + 1) u
| Uv_BVar x -> if n = 0 then sprintf "%d" x else sprintf "(%d + %d)" x n
| Uv_Max us ->
let r = "(max _)" in
if n = 0 then r else sprintf "%s + %d" r n
| _ -> sprintf "<univ>" | false |
Lib.IntVector.Serialize.fst | Lib.IntVector.Serialize.vecs_store_le | val vecs_store_le:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer uint8 (len *! (size (numbytes vt) *! size w))
-> i:lbuffer (vec_t vt w) len ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modi... | val vecs_store_le:
#vt:v_inttype
-> #w:width
-> #len:size_t{v len * (numbytes vt * w) <= max_size_t}
-> o:lbuffer uint8 (len *! (size (numbytes vt) *! size w))
-> i:lbuffer (vec_t vt w) len ->
Stack unit
(requires fun h -> live h i /\ live h o /\ B.disjoint i o)
(ensures fun h0 _ h1 ->
modi... | let vecs_store_le #vt #w #len o i =
let h0 = ST.get () in
[@ inline_let]
let a_spec (i:nat{i <= v len}) = unit in
fill_blocks h0 (size (numbytes vt) *! size w) len o a_spec
(fun _ _ -> ())
(fun _ -> LowStar.Buffer.loc_none)
(fun h -> vecs_to_bytes_le_f (as_seq h i))
(fun j -> vec_store_le (sub ... | {
"file_name": "lib/Lib.IntVector.Serialize.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 78,
"end_line": 128,
"start_col": 0,
"start_line": 117
} | module Lib.IntVector.Serialize
// the proofs are the same as in Lib.ByteSequence and Lib.ByteBuffer
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val vecs_from_bytes_le_f:
vt:v_inttype
-> w:width
-> len:nat{len * (numbytes vt * w) <= max_size_t}
-> b:lseq uint8 (len * (numbytes vt * w))
-> i:na... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Serialize.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Lib.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
o:
Lib.Buffer.lbuffer Lib.IntTypes.uint8
(len *! (Lib.IntTypes.size (Lib.IntTypes.numbytes vt) *! Lib.IntTypes.size w)) ->
i: Lib.Buffer.lbuffer (Lib.IntVector.vec_t vt w) len
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.width",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"... | [] | false | true | false | false | false | let vecs_store_le #vt #w #len o i =
| let h0 = ST.get () in
[@@ inline_let ]let a_spec (i: nat{i <= v len}) = unit in
fill_blocks h0
(size (numbytes vt) *! size w)
len
o
a_spec
(fun _ _ -> ())
(fun _ -> LowStar.Buffer.loc_none)
(fun h -> vecs_to_bytes_le_f (as_seq h i))
(fun j ->
vec_store_le (sub o (j *! (size (numbytes vt) *! size w... | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.collect_binders | val collect_binders (until: (term' -> bool)) (t: term) : list binder & term | val collect_binders (until: (term' -> bool)) (t: term) : list binder & term | let rec collect_binders (until: term' -> bool) (t:term) : list binder & term =
if not (until t.t) then [], t
else (
match t.t with
| Tm_ExistsSL _ b body
| Tm_ForallSL _ b body ->
let bs, t = collect_binders until body in
b::bs, t
| _ -> [], t
) | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 73,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"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 | until: (_: Pulse.Syntax.Base.term' -> Prims.bool) -> t: Pulse.Syntax.Base.term
-> Prims.list Pulse.Syntax.Base.binder * Pulse.Syntax.Base.term | Prims.Tot | [
"total"
] | [] | [
"Pulse.Syntax.Base.term'",
"Prims.bool",
"Pulse.Syntax.Base.term",
"Prims.op_Negation",
"Pulse.Syntax.Base.__proj__Mkterm__item__t",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"Pulse.Syntax.Base.binder",
"Prims.Nil",
"Pulse.Syntax.Base.universe",
"Prims.Cons",
"FStar.Pervasives.Native.t... | [
"recursion"
] | false | false | false | true | false | let rec collect_binders (until: (term' -> bool)) (t: term) : list binder & term =
| if not (until t.t)
then [], t
else
(match t.t with
| Tm_ExistsSL _ b body
| Tm_ForallSL _ b body ->
let bs, t = collect_binders until body in
b :: bs, t
| _ -> [], t) | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_7 | val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\
live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\
LowStar.Monotonic.Buffer.all_disjoint
[ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\
as_n... | val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\
live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\
LowStar.Monotonic.Buffer.all_disjoint
[ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\
as_n... | let point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 =
fmul y3 x3 z3;
fadd y3 y3 t2;
fmul x3 t3 x3;
fsub x3 x3 t1;
fmul z3 t4 z3;
fmul t1 t3 t0;
fadd z3 z3 t1 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 268,
"start_col": 0,
"start_line": 261
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
x3: Hacl.Impl.P256.Bignum.felem ->
y3: Hacl.Impl.P256.Bignum.felem ->
z3: Hacl.Impl.P256.Bignum.felem ->
t0: Hacl.Impl.P256.Bignum.felem ->
t1: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem ->
t3: Hacl.Impl.P256.Bignum.felem ->
t4: Hacl.Impl.P256.Bignum.felem
-> FStar... | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Field.fadd",
"Prims.unit",
"Hacl.Impl.P256.Field.fmul",
"Hacl.Impl.P256.Field.fsub"
] | [] | false | true | false | false | false | let point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 =
| fmul y3 x3 z3;
fadd y3 y3 t2;
fmul x3 t3 x3;
fsub x3 x3 t1;
fmul z3 t4 z3;
fmul t1 t3 t0;
fadd z3 z3 t1 | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_2 | val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit
(requires fun h ->
live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\
live h p /\ live h q /\
LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\
eq_or_disjoint p q /\ disjoint p t1 /\ disjoin... | val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit
(requires fun h ->
live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\
live h p /\ live h q /\
LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\
eq_or_disjoint p q /\ disjoint p t1 /\ disjoin... | let point_add_2 t1 t2 t3 t4 t5 p q =
let y1, z1 = gety p, getz p in
let y2, z2 = gety q, getz q in
fsub t3 t3 t4;
fadd t4 y1 z1;
fadd t5 y2 z2;
fmul t4 t4 t5;
fadd t5 t1 t2;
fsub t4 t4 t5 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 99,
"start_col": 0,
"start_line": 91
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
t1: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem ->
t3: Hacl.Impl.P256.Bignum.felem ->
t4: Hacl.Impl.P256.Bignum.felem ->
t5: Hacl.Impl.P256.Bignum.felem ->
p: Hacl.Impl.P256.Point.point ->
q: Hacl.Impl.P256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Field.fsub",
"Prims.unit",
"Hacl.Impl.P256.Field.fadd",
"Hacl.Impl.P256.Field.fmul",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Impl.P256.Point.getz",
"Hacl.Impl.P256.Point.gety"
] | [] | false | true | false | false | false | let point_add_2 t1 t2 t3 t4 t5 p q =
| let y1, z1 = gety p, getz p in
let y2, z2 = gety q, getz q in
fsub t3 t3 t4;
fadd t4 y1 z1;
fadd t5 y2 z2;
fmul t4 t4 t5;
fadd t5 t1 t2;
fsub t4 t4 t5 | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_3 | val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\
live h p /\ live h q /\
LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\
eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\
disjoint p... | val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\
live h p /\ live h q /\
LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\
eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\
disjoint p... | let point_add_3 x3 y3 t0 t2 p q =
let x1, z1 = getx p, getz p in
let x2, z2 = getx q, getz q in
fadd x3 x1 z1;
fadd y3 x2 z2;
fmul x3 x3 y3;
fadd y3 t0 t2;
fsub y3 x3 y3 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 133,
"start_col": 0,
"start_line": 126
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
x3: Hacl.Impl.P256.Bignum.felem ->
y3: Hacl.Impl.P256.Bignum.felem ->
t0: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem ->
p: Hacl.Impl.P256.Point.point ->
q: Hacl.Impl.P256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Field.fsub",
"Prims.unit",
"Hacl.Impl.P256.Field.fadd",
"Hacl.Impl.P256.Field.fmul",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Impl.P256.Point.getz",
"Hacl.Impl.P256.Point.getx"
] | [] | false | true | false | false | false | let point_add_3 x3 y3 t0 t2 p q =
| let x1, z1 = getx p, getz p in
let x2, z2 = getx q, getz q in
fadd x3 x1 z1;
fadd y3 x2 z2;
fmul x3 x3 y3;
fadd y3 t0 t2;
fsub y3 x3 y3 | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_1 | val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit
(requires fun h ->
live h t0 /\ live h t1 /\ live h t2 /\
live h t3 /\ live h t4 /\ live h p /\ live h q /\
LowStar.Monotonic.Buffer.all_disjoint
[loc t0; loc t1; loc t2; loc t3; loc t4 ] /\
eq_or_disjoint p q /\ disjoint p t0 /\ di... | val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit
(requires fun h ->
live h t0 /\ live h t1 /\ live h t2 /\
live h t3 /\ live h t4 /\ live h p /\ live h q /\
LowStar.Monotonic.Buffer.all_disjoint
[loc t0; loc t1; loc t2; loc t3; loc t4 ] /\
eq_or_disjoint p q /\ disjoint p t0 /\ di... | let point_add_1 t0 t1 t2 t3 t4 p q =
let x1, y1, z1 = getx p, gety p, getz p in
let x2, y2, z2 = getx q, gety q, getz q in
fmul t0 x1 x2;
fmul t1 y1 y2;
fmul t2 z1 z2;
fadd t3 x1 y1;
fadd t4 x2 y2;
fmul t3 t3 t4;
fadd t4 t0 t1 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 57,
"start_col": 0,
"start_line": 48
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
t0: Hacl.Impl.P256.Bignum.felem ->
t1: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem ->
t3: Hacl.Impl.P256.Bignum.felem ->
t4: Hacl.Impl.P256.Bignum.felem ->
p: Hacl.Impl.P256.Point.point ->
q: Hacl.Impl.P256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Field.fadd",
"Prims.unit",
"Hacl.Impl.P256.Field.fmul",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.Mktuple3",
"Hacl.Impl.P256.Point.getz",
"Hacl.Impl.P256.Point.gety",
"Hacl.Impl.P256.Point.getx"
] | [] | false | true | false | false | false | let point_add_1 t0 t1 t2 t3 t4 p q =
| let x1, y1, z1 = getx p, gety p, getz p in
let x2, y2, z2 = getx q, gety q, getz q in
fmul t0 x1 x2;
fmul t1 y1 y2;
fmul t2 z1 z2;
fadd t3 x1 y1;
fadd t4 x2 y2;
fmul t3 t3 t4;
fadd t4 t0 t1 | false |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.term_to_doc | val term_to_doc (t:term) : T.Tac document | val term_to_doc (t:term) : T.Tac document | let rec binder_to_doc b : T.Tac document =
parens (doc_of_string (T.unseal b.binder_ppname.name)
^^ doc_of_string ":"
^^ term_to_doc b.binder_ty)
and term_to_doc t
: T.Tac document
= match t.t with
| Tm_Emp -> doc_of_string "emp"
| Tm_Pure p -> doc_of_string "pure" ^^ parens (term_to... | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 166,
"start_col": 0,
"start_line": 128
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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: Pulse.Syntax.Base.term -> FStar.Tactics.Effect.Tac FStar.Stubs.Pprint.document | FStar.Tactics.Effect.Tac | [] | [
"binder_to_doc",
"term_to_doc"
] | [
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.__proj__Mkterm__item__t",
"FStar.Stubs.Pprint.doc_of_string",
"FStar.Stubs.Pprint.document",
"FStar.Stubs.Pprint.op_Hat_Hat",
"FStar.Stubs.Pprint.parens",
"Pulse.Syntax.Printer.term_to_doc",
"FStar.Stubs.Pprint.infix",
"Pulse.Syntax.Base.universe",
"Pul... | [
"mutual recursion"
] | false | true | false | false | false | let rec term_to_doc t : T.Tac document =
| match t.t with
| Tm_Emp -> doc_of_string "emp"
| Tm_Pure p -> doc_of_string "pure" ^^ parens (term_to_doc p)
| Tm_Star p1 p2 -> infix 2 1 (doc_of_string "**") (term_to_doc p1) (term_to_doc p2)
| Tm_ExistsSL _ _ _ ->
let bs, body = collect_binders Tm_ExistsSL? t in
parens (doc_of_string "exists*" ^/^
(separate... | false |
Hacl.Impl.P256.PointAdd.fst | Hacl.Impl.P256.PointAdd.point_add_6 | val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\
live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\
LowStar.Monotonic.Buffer.all_disjoint
[ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\
as_nat h y3 < S.prime /\ as_... | val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit
(requires fun h ->
live h x3 /\ live h y3 /\ live h z3 /\
live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\
LowStar.Monotonic.Buffer.all_disjoint
[ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\
as_nat h y3 < S.prime /\ as_... | let point_add_6 x3 y3 z3 t0 t1 t2 t4 =
fadd y3 t1 y3;
fdouble t1 t0;
fadd t0 t1 t0;
fsub t0 t0 t2;
fmul t1 t4 y3;
fmul t2 t0 y3 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.PointAdd.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 228,
"start_col": 0,
"start_line": 222
} | module Hacl.Impl.P256.PointAdd
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module S = Spec.P256
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextrac... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.Field.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"FStar.UInt32.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Field",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 |
x3: Hacl.Impl.P256.Bignum.felem ->
y3: Hacl.Impl.P256.Bignum.felem ->
z3: Hacl.Impl.P256.Bignum.felem ->
t0: Hacl.Impl.P256.Bignum.felem ->
t1: Hacl.Impl.P256.Bignum.felem ->
t2: Hacl.Impl.P256.Bignum.felem ->
t4: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Field.fmul",
"Prims.unit",
"Hacl.Impl.P256.Field.fsub",
"Hacl.Impl.P256.Field.fadd",
"Hacl.Impl.P256.Field.fdouble"
] | [] | false | true | false | false | false | let point_add_6 x3 y3 z3 t0 t1 t2 t4 =
| fadd y3 t1 y3;
fdouble t1 t0;
fadd t0 t1 t0;
fsub t0 t0 t2;
fmul t1 t4 y3;
fmul t2 t0 y3 | false |
Hacl.Impl.RSAPSS.Padding.fst | Hacl.Impl.RSAPSS.Padding.em_len_t | val em_len_t : a: Spec.Hash.Definitions.fixed_len_alg -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> Type0 | let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) =
emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Padding.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 35,
"start_col": 0,
"start_line": 34
} | module Hacl.Impl.RSAPSS.Padding
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.RSAPSS.MGF
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Hash = Spec.Agile.Hash
module S = Spec.RSAPSS
module BD = Hacl.Bignum.Definitions
#reset-opti... | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"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 | a: Spec.Hash.Definitions.fixed_len_alg -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.fixed_len_alg",
"Hacl.Impl.RSAPSS.Padding.salt_len_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
... | [] | false | false | false | false | true | let em_len_t (a: Hash.fixed_len_alg) (saltLen: salt_len_t a) =
| emBits: size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} | false | |
Pulse.Syntax.Printer.fst | Pulse.Syntax.Printer.ctag_to_string | val ctag_to_string (c:ctag) : string | val ctag_to_string (c:ctag) : string | let ctag_to_string = function
| STT -> "ST"
| STT_Atomic -> "STAtomic"
| STT_Ghost -> "STGhost" | {
"file_name": "lib/steel/pulse/Pulse.Syntax.Printer.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 26,
"end_line": 180,
"start_col": 0,
"start_line": 177
} | (*
Copyright 2023 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": [
"Pulse.Syntax.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.String.fsti.checked",
"FStar.Sealed.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checke... | [
{
"abbrev": true,
"full_module": "FStar.Sealed",
"short_module": "Un"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Printf",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"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: Pulse.Syntax.Base.ctag -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Pulse.Syntax.Base.ctag",
"Prims.string"
] | [] | false | false | false | true | false | let ctag_to_string =
| function
| STT -> "ST"
| STT_Atomic -> "STAtomic"
| STT_Ghost -> "STGhost" | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.