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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.parse_int32le | val parse_int32le:parser (total_constant_size_parser_kind 4) U32.t | val parse_int32le:parser (total_constant_size_parser_kind 4) U32.t | let parse_int32le : parser (total_constant_size_parser_kind 4) U32.t
= decode_int32le_total_constant () ;
make_total_constant_size_parser 4 U32.t decode_int32le | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 56,
"end_line": 53,
"start_col": 0,
"start_line": 51
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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 | LowParse.Spec.Base.parser (LowParse.Spec.Base.total_constant_size_parser_kind 4) FStar.UInt32.t | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Combinators.make_total_constant_size_parser",
"FStar.UInt32.t",
"LowParse.Spec.Int32le.decode_int32le",
"Prims.unit",
"LowParse.Spec.Int32le.decode_int32le_total_constant"
] | [] | false | false | false | false | false | let parse_int32le:parser (total_constant_size_parser_kind 4) U32.t =
| decode_int32le_total_constant ();
make_total_constant_size_parser 4 U32.t decode_int32le | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.decode_int32le | val decode_int32le (b: bytes{Seq.length b == 4})
: Tot (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296}) | val decode_int32le (b: bytes{Seq.length b == 4})
: Tot (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296}) | let decode_int32le
(b: bytes { Seq.length b == 4 } )
: Tot (v: U32.t { 0 <= U32.v v /\ U32.v v < 4294967296 } )
= lemma_le_to_n_is_bounded b;
M.pow2_le_compat 32 32;
let res = le_to_n b in
assert (0 <= res /\ res < 4294967296);
U32.uint_to_t res | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 19,
"end_line": 28,
"start_col": 0,
"start_line": 21
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 4}
-> v: FStar.UInt32.t{0 <= FStar.UInt32.v v /\ FStar.UInt32.v v < 4294967296} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.UInt32.uint_to_t",
"Prims.unit",
"Prims._assert",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.nat",
"FStar.Endianness.le_to_n",
"FStar.Math.Lem... | [] | false | false | false | false | false | let decode_int32le (b: bytes{Seq.length b == 4})
: Tot (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296}) =
| lemma_le_to_n_is_bounded b;
M.pow2_le_compat 32 32;
let res = le_to_n b in
assert (0 <= res /\ res < 4294967296);
U32.uint_to_t res | false |
LowParse.Slice.fst | LowParse.Slice.make_slice | val make_slice (#rrel #rel: _) (b: B.mbuffer byte rrel rel) (len: U32.t{U32.v len <= B.length b})
: Tot (slice (srel_of_buffer_srel rrel) (srel_of_buffer_srel rel)) | val make_slice (#rrel #rel: _) (b: B.mbuffer byte rrel rel) (len: U32.t{U32.v len <= B.length b})
: Tot (slice (srel_of_buffer_srel rrel) (srel_of_buffer_srel rel)) | let make_slice
(#rrel #rel: _)
(b: B.mbuffer byte rrel rel)
(len: U32.t { U32.v len <= B.length b } )
: Tot (slice (srel_of_buffer_srel rrel) (srel_of_buffer_srel rel))
= {
base = b;
len = len;
} | {
"file_name": "src/lowparse/LowParse.Slice.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 44,
"start_col": 0,
"start_line": 36
} | module LowParse.Slice
open LowParse.Bytes
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
inline_for_extraction
noextract
type srel (a: Type) = (B.srel a)
inline_for_extraction
noextract
let buffer_srel_of_srel (#a: Type) (s: srel a) : Tot (B.srel a) =
s
inline_for_extra... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Bytes.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"s... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: LowStar.Monotonic.Buffer.mbuffer LowParse.Bytes.byte rrel rel ->
len: FStar.UInt32.t{FStar.UInt32.v len <= LowStar.Monotonic.Buffer.length b}
-> LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel rrel)
(LowParse.Slice.srel_of_buffer_srel rel) | Prims.Tot | [
"total"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowParse.Slice.Mkslice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Slice.slice"
] | [] | false | false | false | false | false | let make_slice (#rrel #rel: _) (b: B.mbuffer byte rrel rel) (len: U32.t{U32.v len <= B.length b})
: Tot (slice (srel_of_buffer_srel rrel) (srel_of_buffer_srel rel)) =
| { base = b; len = len } | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.le_to_n_0_eq | val le_to_n_0_eq (b: bytes{Seq.length b == 0}) : Lemma (le_to_n b == 0) | val le_to_n_0_eq (b: bytes{Seq.length b == 0}) : Lemma (le_to_n b == 0) | let le_to_n_0_eq
(b : bytes { Seq.length b == 0 } )
: Lemma (le_to_n b == 0)
= reveal_le_to_n b | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 63,
"start_col": 0,
"start_line": 60
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 0}
-> FStar.Pervasives.Lemma (ensures FStar.Endianness.le_to_n b == 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Endianness.reveal_le_to_n",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Endianness.le_to_n",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let le_to_n_0_eq (b: bytes{Seq.length b == 0}) : Lemma (le_to_n b == 0) =
| reveal_le_to_n b | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.decode_int32le_total_constant | val decode_int32le_total_constant: Prims.unit
-> Lemma (make_total_constant_size_parser_precond 4 U32.t decode_int32le) | val decode_int32le_total_constant: Prims.unit
-> Lemma (make_total_constant_size_parser_precond 4 U32.t decode_int32le) | let decode_int32le_total_constant () : Lemma (make_total_constant_size_parser_precond 4 U32.t decode_int32le)
= Classical.forall_intro_2 decode_int32le_injective | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 51,
"end_line": 49,
"start_col": 0,
"start_line": 48
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Combinators.make_total_constant_size_parser_precond 4
FStar.UInt32.t
LowParse.Spec.Int32le.decode_int32le) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.l_imp",
"FStar.UInt32.t",
"Prims.l_or",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_LessThan",
... | [] | false | false | true | false | false | let decode_int32le_total_constant ()
: Lemma (make_total_constant_size_parser_precond 4 U32.t decode_int32le) =
| Classical.forall_intro_2 decode_int32le_injective | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.equal | val equal (#a:Type) (m1 m2:map16 a) : Type0 | val equal (#a:Type) (m1 m2:map16 a) : Type0 | let equal #a m1 m2 = m1 == m2 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 67,
"start_col": 0,
"start_line": 67
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m1: Vale.Lib.Map16.map16 a -> m2: Vale.Lib.Map16.map16 a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Lib.Map16.map16",
"Prims.eq2"
] | [] | false | false | false | true | true | let equal #a m1 m2 =
| m1 == m2 | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.serialize_int32le | val serialize_int32le:serializer parse_int32le | val serialize_int32le:serializer parse_int32le | let serialize_int32le : serializer parse_int32le
= fun (x : U32.t) -> n_to_le 4 (U32.v x) | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 40,
"end_line": 56,
"start_col": 0,
"start_line": 55
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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 | LowParse.Spec.Base.serializer LowParse.Spec.Int32le.parse_int32le | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"FStar.Endianness.n_to_le",
"FStar.UInt32.v",
"FStar.Endianness.bytes",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Endianness.le_to_n"
] | [] | false | false | false | false | false | let serialize_int32le:serializer parse_int32le =
| fun (x: U32.t) -> n_to_le 4 (U32.v x) | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.le_to_n_2_eq | val le_to_n_2_eq (b: bytes{Seq.length b == 2})
: Lemma (le_to_n b == U8.v (Seq.index b 0) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1))) | val le_to_n_2_eq (b: bytes{Seq.length b == 2})
: Lemma (le_to_n b == U8.v (Seq.index b 0) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1))) | let le_to_n_2_eq
(b : bytes { Seq.length b == 2 } )
: Lemma (le_to_n b ==
U8.v (Seq.index b 0) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1)))
= assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_1_eq (Seq.tail b) | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 80,
"start_col": 0,
"start_line": 73
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 2}
-> FStar.Pervasives.Lemma
(ensures
FStar.Endianness.le_to_n b ==
FStar.UInt8.v (FStar.Seq.Base.index b 0) + 256 * FStar.UInt8.v (FStar.Seq.Base.index b 1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Int32le.le_to_n_1_eq",
"FStar.Seq.Properties.tail",
"Prims.unit",
"FStar.Endianness.reveal_le_to_n",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims.l_True",
"Prims.squash",
... | [] | true | false | true | false | false | let le_to_n_2_eq (b: bytes{Seq.length b == 2})
: Lemma (le_to_n b == U8.v (Seq.index b 0) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1))) =
| assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_1_eq (Seq.tail b) | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.le_to_n_3_eq | val le_to_n_3_eq (b: bytes{Seq.length b == 3})
: Lemma
(le_to_n b ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 2)))) | val le_to_n_3_eq (b: bytes{Seq.length b == 3})
: Lemma
(le_to_n b ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 2)))) | let le_to_n_3_eq
(b : bytes { Seq.length b == 3 } )
: Lemma (le_to_n b ==
U8.v (Seq.index b 0) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 2))))
= assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_2_eq (Seq.tail b) | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 90,
"start_col": 0,
"start_line": 82
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 3}
-> FStar.Pervasives.Lemma
(ensures
FStar.Endianness.le_to_n b ==
FStar.UInt8.v (FStar.Seq.Base.index b 0) +
256 *
(FStar.UInt8.v (FStar.Seq.Base.index b 1) + 256 * FStar.UInt8.v (FStar.Seq.Base.index b 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Int32le.le_to_n_2_eq",
"FStar.Seq.Properties.tail",
"Prims.unit",
"FStar.Endianness.reveal_le_to_n",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims.l_True",
"Prims.squash",
... | [] | true | false | true | false | false | let le_to_n_3_eq (b: bytes{Seq.length b == 3})
: Lemma
(le_to_n b ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 2)))) =
| assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_2_eq (Seq.tail b) | false |
FStar.Pervasives.fst | FStar.Pervasives.spinoff | val spinoff (p: Type0) : Type0 | val spinoff (p: Type0) : Type0 | let spinoff p = p | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | true | let spinoff p =
| p | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.le_to_n_1_eq | val le_to_n_1_eq (b: bytes{Seq.length b == 1}) : Lemma (le_to_n b == U8.v (Seq.index b 0)) | val le_to_n_1_eq (b: bytes{Seq.length b == 1}) : Lemma (le_to_n b == U8.v (Seq.index b 0)) | let le_to_n_1_eq
(b : bytes { Seq.length b == 1 } )
: Lemma (le_to_n b ==
U8.v (Seq.index b 0))
= assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_0_eq (Seq.tail b) | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 71,
"start_col": 0,
"start_line": 65
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 1}
-> FStar.Pervasives.Lemma
(ensures FStar.Endianness.le_to_n b == FStar.UInt8.v (FStar.Seq.Base.index b 0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Int32le.le_to_n_0_eq",
"FStar.Seq.Properties.tail",
"Prims.unit",
"FStar.Endianness.reveal_le_to_n",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims.l_True",
"Prims.squash",
... | [] | true | false | true | false | false | let le_to_n_1_eq (b: bytes{Seq.length b == 1}) : Lemma (le_to_n b == U8.v (Seq.index b 0)) =
| assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_0_eq (Seq.tail b) | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.decode_int32le_injective | val decode_int32le_injective (b1: bytes{Seq.length b1 == 4}) (b2: bytes{Seq.length b2 == 4})
: Lemma (decode_int32le b1 == decode_int32le b2 ==> b1 == b2) | val decode_int32le_injective (b1: bytes{Seq.length b1 == 4}) (b2: bytes{Seq.length b2 == 4})
: Lemma (decode_int32le b1 == decode_int32le b2 ==> b1 == b2) | let decode_int32le_injective
(b1 : bytes { Seq.length b1 == 4 } )
(b2 : bytes { Seq.length b2 == 4 } )
: Lemma (decode_int32le b1 == decode_int32le b2
==>
b1 == b2)
= if (decode_int32le b1) = (decode_int32le b2) then
begin
lemma_le_to_n_is_bounded b1;
lemma_le_to_n_is_bounded b2;
asser... | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 46,
"start_col": 0,
"start_line": 30
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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 |
b1: LowParse.Bytes.bytes{FStar.Seq.Base.length b1 == 4} ->
b2: LowParse.Bytes.bytes{FStar.Seq.Base.length b2 == 4}
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Int32le.decode_int32le b1 == LowParse.Spec.Int32le.decode_int32le b2 ==>
b1 == b2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.op_Equality",
"FStar.UInt32.t",
"Prims.l_or",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_LessThan",
"LowParse.Spec.Int32le.decode_int32le",
"F... | [] | false | false | true | false | false | let decode_int32le_injective (b1: bytes{Seq.length b1 == 4}) (b2: bytes{Seq.length b2 == 4})
: Lemma (decode_int32le b1 == decode_int32le b2 ==> b1 == b2) =
| if (decode_int32le b1) = (decode_int32le b2)
then
(lemma_le_to_n_is_bounded b1;
lemma_le_to_n_is_bounded b2;
assert (U32.v (U32.uint_to_t (le_to_n b1)) == le_to_n b1);
assert (U32.v (U32.uint_to_t (le_to_n b2)) == le_to_n b2);
assert (le_to_n b1 == le_to_n b2);
le_to_n_inj b1 b2) | false |
FStar.Pervasives.fst | FStar.Pervasives.ambient | val ambient (#a: Type) (x: a) : Type0 | val ambient (#a: Type) (x: a) : Type0 | let ambient #_ _ = True | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 38,
"start_col": 0,
"start_line": 38
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.l_True"
] | [] | false | false | false | true | true | let ambient #_ _ =
| True | false |
FStar.Pervasives.fst | FStar.Pervasives.normalize | val normalize (a: Type0) : Type0 | val normalize (a: Type0) : Type0 | let normalize a = a | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 44,
"start_col": 0,
"start_line": 44
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | true | let normalize a =
| a | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.le_to_n_4_eq | val le_to_n_4_eq (b: bytes{Seq.length b == 4})
: Lemma
(le_to_n b ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 2) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3))))) | val le_to_n_4_eq (b: bytes{Seq.length b == 4})
: Lemma
(le_to_n b ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 2) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3))))) | let le_to_n_4_eq
(b : bytes { Seq.length b == 4 } )
: Lemma (le_to_n b ==
U8.v (Seq.index b 0) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 2) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3)))))
= assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le... | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 101,
"start_col": 0,
"start_line": 92
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 4}
-> FStar.Pervasives.Lemma
(ensures
FStar.Endianness.le_to_n b ==
FStar.UInt8.v (FStar.Seq.Base.index b 0) +
256 *
(FStar.UInt8.v (FStar.Seq.Base.index b 1) +
256 *
(FStar.UInt8.v (FStar.Seq.Base.index b 2) + 256 * FStar.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Int32le.le_to_n_3_eq",
"FStar.Seq.Properties.tail",
"Prims.unit",
"FStar.Endianness.reveal_le_to_n",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims.l_True",
"Prims.squash",
... | [] | true | false | true | false | false | let le_to_n_4_eq (b: bytes{Seq.length b == 4})
: Lemma
(le_to_n b ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 2) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3))))) =
| assert_norm (pow2 8 == 256);
reveal_le_to_n b;
le_to_n_3_eq (Seq.tail b) | false |
FStar.Pervasives.fst | FStar.Pervasives.normalize_term | val normalize_term (#a: Type) (x: a) : Tot a | val normalize_term (#a: Type) (x: a) : Tot a | let normalize_term #_ x = x | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 42,
"start_col": 0,
"start_line": 42
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> a | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let normalize_term #_ x =
| x | false |
FStar.Pervasives.fst | FStar.Pervasives.simplify | val simplify : norm_step | val simplify : norm_step | let simplify = Simpl | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 71,
"start_col": 0,
"start_line": 71
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Simpl"
] | [] | false | false | false | true | false | let simplify =
| Simpl | false |
FStar.Pervasives.fst | FStar.Pervasives.weak | val weak : norm_step | val weak : norm_step | let weak = Weak | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 74,
"start_col": 0,
"start_line": 74
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Weak"
] | [] | false | false | false | true | false | let weak =
| Weak | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_equal | val lemma_equal (#a:Type) (m1 m2:map16 a) : Lemma
(requires (forall (i:int).{:pattern (sel m1 i) \/ (sel m2 i)} 0 <= i /\ i < 16 ==> sel m1 i == sel m2 i))
(ensures m1 == m2) | val lemma_equal (#a:Type) (m1 m2:map16 a) : Lemma
(requires (forall (i:int).{:pattern (sel m1 i) \/ (sel m2 i)} 0 <= i /\ i < 16 ==> sel m1 i == sel m2 i))
(ensures m1 == m2) | let lemma_equal (#a:Type) (m1 m2:map16 a) =
assert_norm (forall (i:int). sel m1 i == sel16 m1 i);
assert_norm (forall (i:int). sel m2 i == sel16 m2 i);
lemma_equal16 m1 m2 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 40,
"start_col": 0,
"start_line": 37
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m1: Vale.Lib.Map16.map16 a -> m2: Vale.Lib.Map16.map16 a
-> FStar.Pervasives.Lemma
(requires
forall (i: Prims.int). {:pattern Vale.Lib.Map16.sel m1 i\/Vale.Lib.Map16.sel m2 i}
0 <= i /\ i < 16 ==> Vale.Lib.Map16.sel m1 i == Vale.Lib.Map16.sel m2 i)
(ensures m1 == m2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Vale.Lib.Map16.lemma_equal16",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.l_Forall",
"Prims.int",
"Prims.eq2",
"Vale.Lib.Map16.sel",
"Vale.Lib.Map16.sel16"
] | [] | false | false | true | false | false | let lemma_equal (#a: Type) (m1 m2: map16 a) =
| assert_norm (forall (i: int). sel m1 i == sel16 m1 i);
assert_norm (forall (i: int). sel m2 i == sel16 m2 i);
lemma_equal16 m1 m2 | false |
FStar.Pervasives.fst | FStar.Pervasives.delta | val delta : norm_step | val delta : norm_step | let delta = Delta | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 83,
"start_col": 0,
"start_line": 83
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Delta"
] | [] | false | false | false | true | false | let delta =
| Delta | false |
FStar.Pervasives.fst | FStar.Pervasives.primops | val primops : norm_step | val primops : norm_step | let primops = Primops | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 80,
"start_col": 0,
"start_line": 80
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Primops"
] | [] | false | false | false | true | false | let primops =
| Primops | false |
FStar.Pervasives.fst | FStar.Pervasives.norm_debug | val norm_debug : norm_step | val norm_debug : norm_step | let norm_debug = NormDebug | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 86,
"start_col": 0,
"start_line": 86
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.NormDebug"
] | [] | false | false | false | true | false | let norm_debug =
| NormDebug | false |
FStar.Pervasives.fst | FStar.Pervasives.hnf | val hnf : norm_step | val hnf : norm_step | let hnf = HNF | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 77,
"start_col": 0,
"start_line": 77
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.HNF"
] | [] | false | false | false | true | false | let hnf =
| HNF | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_other | val lemma_other (#a:Type) (m:map16 a) (n1 n2:int) (v:a) : Lemma
(requires 0 <= n1 /\ n1 < 16 /\ 0 <= n2 /\ n2 < 16 /\ n1 =!= n2)
(ensures sel (upd m n1 v) n2 == sel m n2)
[SMTPat (sel (upd m n1 v) n2)] | val lemma_other (#a:Type) (m:map16 a) (n1 n2:int) (v:a) : Lemma
(requires 0 <= n1 /\ n1 < 16 /\ 0 <= n2 /\ n2 < 16 /\ n1 =!= n2)
(ensures sel (upd m n1 v) n2 == sel m n2)
[SMTPat (sel (upd m n1 v) n2)] | let lemma_other (#a:Type) (m:map16 a) (n1 n2:int) (v:a) =
assert_norm (sel (upd m n1 v) n2 == sel16 (upd16 m n1 v) n2);
assert_norm (sel m n2 == sel16 m n2);
lemma_other16 m n1 n2 v | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 35,
"start_col": 0,
"start_line": 32
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m: Vale.Lib.Map16.map16 a -> n1: Prims.int -> n2: Prims.int -> v: a
-> FStar.Pervasives.Lemma (requires 0 <= n1 /\ n1 < 16 /\ 0 <= n2 /\ n2 < 16 /\ ~(n1 == n2))
(ensures Vale.Lib.Map16.sel (Vale.Lib.Map16.upd m n1 v) n2 == Vale.Lib.Map16.sel m n2)
[SMTPat (Vale.Lib.Map16.sel (Vale.Lib.Map16.upd m n1 v) n2... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Prims.int",
"Vale.Lib.Map16.lemma_other16",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.Lib.Map16.sel",
"Vale.Lib.Map16.sel16",
"Vale.Lib.Map16.upd",
"Vale.Lib.Map16.upd16"
] | [] | true | false | true | false | false | let lemma_other (#a: Type) (m: map16 a) (n1 n2: int) (v: a) =
| assert_norm (sel (upd m n1 v) n2 == sel16 (upd16 m n1 v) n2);
assert_norm (sel m n2 == sel16 m n2);
lemma_other16 m n1 n2 v | false |
FStar.Pervasives.fst | FStar.Pervasives.iota | val iota : norm_step | val iota : norm_step | let iota = Iota | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 95,
"start_col": 0,
"start_line": 95
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Iota"
] | [] | false | false | false | true | false | let iota =
| Iota | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_self | val lemma_self (#a:Type) (m:map16 a) (n:int) (v:a) : Lemma
(requires 0 <= n /\ n < 16)
(ensures sel (upd m n v) n == v)
[SMTPat (sel (upd m n v) n)] | val lemma_self (#a:Type) (m:map16 a) (n:int) (v:a) : Lemma
(requires 0 <= n /\ n < 16)
(ensures sel (upd m n v) n == v)
[SMTPat (sel (upd m n v) n)] | let lemma_self (#a:Type) (m:map16 a) (n:int) (v:a) =
assert_norm (sel (upd m n v) n == sel16 (upd16 m n v) n);
lemma_self16 m n v | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 30,
"start_col": 0,
"start_line": 28
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m: Vale.Lib.Map16.map16 a -> n: Prims.int -> v: a
-> FStar.Pervasives.Lemma (requires 0 <= n /\ n < 16)
(ensures Vale.Lib.Map16.sel (Vale.Lib.Map16.upd m n v) n == v)
[SMTPat (Vale.Lib.Map16.sel (Vale.Lib.Map16.upd m n v) n)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Prims.int",
"Vale.Lib.Map16.lemma_self16",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.Lib.Map16.sel",
"Vale.Lib.Map16.upd",
"Vale.Lib.Map16.sel16",
"Vale.Lib.Map16.upd16"
] | [] | true | false | true | false | false | let lemma_self (#a: Type) (m: map16 a) (n: int) (v: a) =
| assert_norm (sel (upd m n v) n == sel16 (upd16 m n v) n);
lemma_self16 m n v | false |
FStar.Pervasives.fst | FStar.Pervasives.zeta | val zeta : norm_step | val zeta : norm_step | let zeta = Zeta | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 89,
"start_col": 0,
"start_line": 89
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Zeta"
] | [] | false | false | false | true | false | let zeta =
| Zeta | false |
FStar.Pervasives.fst | FStar.Pervasives.zeta_full | val zeta_full : norm_step | val zeta_full : norm_step | let zeta_full = ZetaFull | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 92,
"start_col": 0,
"start_line": 92
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.ZetaFull"
] | [] | false | false | false | true | false | let zeta_full =
| ZetaFull | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_equal16 | val lemma_equal16 (#a:Type) (m1 m2:map16 a) : Lemma
(requires (forall (i:int).{:pattern (sel16 m1 i) \/ (sel16 m2 i)} 0 <= i /\ i < 16 ==> sel16 m1 i == sel16 m2 i))
(ensures m1 == m2) | val lemma_equal16 (#a:Type) (m1 m2:map16 a) : Lemma
(requires (forall (i:int).{:pattern (sel16 m1 i) \/ (sel16 m2 i)} 0 <= i /\ i < 16 ==> sel16 m1 i == sel16 m2 i))
(ensures m1 == m2) | let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == sel16 m2 1);
assert (sel16 m1 2 == sel16 m2 2);
assert (sel16 m1 3 == sel16 m2 3);
assert (sel16 m1 4 == sel16 m2 4);
assert (sel16 m1 5 == sel16 m2 5);
assert (sel16 m1 6 == sel16 m2 6);
... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 25,
"start_col": 0,
"start_line": 8
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 5,
"max_fuel": 1,
"max_ifuel": 5,
"no_plugins": 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 | m1: Vale.Lib.Map16.map16 a -> m2: Vale.Lib.Map16.map16 a
-> FStar.Pervasives.Lemma
(requires
forall (i: Prims.int). {:pattern Vale.Lib.Map16.sel16 m1 i\/Vale.Lib.Map16.sel16 m2 i}
0 <= i /\ i < 16 ==> Vale.Lib.Map16.sel16 m1 i == Vale.Lib.Map16.sel16 m2 i)
(ensures m1 == m2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Vale.Lib.Map16.sel16"
] | [] | true | false | true | false | false | let lemma_equal16 (#a: Type) (m1 m2: map16 a) =
| assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == sel16 m2 1);
assert (sel16 m1 2 == sel16 m2 2);
assert (sel16 m1 3 == sel16 m2 3);
assert (sel16 m1 4 == sel16 m2 4);
assert (sel16 m1 5 == sel16 m2 5);
assert (sel16 m1 6 == sel16 m2 6);
assert (sel16 m1 7 == sel16 m2 7);
assert (sel16 m1 8 == sel16 m2 8);
asser... | false |
FStar.Pervasives.fst | FStar.Pervasives.nbe | val nbe : norm_step | val nbe : norm_step | let nbe = NBE | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 98,
"start_col": 0,
"start_line": 98
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.NBE"
] | [] | false | false | false | true | false | let nbe =
| NBE | false |
FStar.Pervasives.fst | FStar.Pervasives.reify_ | val reify_ : norm_step | val reify_ : norm_step | let reify_ = Reify | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 101,
"start_col": 0,
"start_line": 101
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Reify"
] | [] | false | false | false | true | false | let reify_ =
| Reify | false |
LowParse.Spec.Int32le.fst | LowParse.Spec.Int32le.decode_int32le_eq | val decode_int32le_eq (b: bytes{Seq.length b == 4})
: Lemma
(U32.v (decode_int32le b) ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 2) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3))))) | val decode_int32le_eq (b: bytes{Seq.length b == 4})
: Lemma
(U32.v (decode_int32le b) ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 2) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3))))) | let decode_int32le_eq
(b : bytes { Seq.length b == 4 } )
: Lemma
(U32.v (decode_int32le b) ==
U8.v (Seq.index b 0) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 1) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 2) +
256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3)))))
= lemma_le_to_n_is_bounded b;
as... | {
"file_name": "src/lowparse/LowParse.Spec.Int32le.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 113,
"start_col": 0,
"start_line": 103
} | module LowParse.Spec.Int32le
(* LowParse specification module for parsing unconstrainted 32 bits = 4 bytes unsigned little endian integers
Examples:
uint32le foo
*)
include FStar.Endianness
include LowParse.Spec.Base
include LowParse.Spec.Combinators
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt... | {
"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: LowParse.Bytes.bytes{FStar.Seq.Base.length b == 4}
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt32.v (LowParse.Spec.Int32le.decode_int32le b) ==
FStar.UInt8.v (FStar.Seq.Base.index b 0) +
256 *
(FStar.UInt8.v (FStar.Seq.Base.index b 1) +
256 *
(FStar.UInt8.v (FStar.Seq.B... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Int32le.le_to_n_4_eq",
"Prims.unit",
"Prims._assert",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowPars... | [] | true | false | true | false | false | let decode_int32le_eq (b: bytes{Seq.length b == 4})
: Lemma
(U32.v (decode_int32le b) ==
U8.v (Seq.index b 0) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 1) +
256
`FStar.Mul.op_Star`
(U8.v (Seq.index b 2) + 256 `FStar.Mul.op_Star` (U8.v (Seq.index b 3))))) =
| lemma_le_to_n_is_bounded b;
assert (U32.v (decode_int32le b) == le_to_n b);
le_to_n_4_eq b | false |
FStar.Pervasives.fst | FStar.Pervasives.delta_only | val delta_only (s: list string) : Tot norm_step | val delta_only (s: list string) : Tot norm_step | let delta_only s = UnfoldOnly s | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 104,
"start_col": 0,
"start_line": 104
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Prims.list Prims.string -> FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldOnly",
"FStar.Pervasives.norm_step"
] | [] | false | false | false | true | false | let delta_only s =
| UnfoldOnly s | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_eta16 | val lemma_eta16 (#a:Type) (m:map16 a) : Lemma
(ensures eta16 m == m) | val lemma_eta16 (#a:Type) (m:map16 a) : Lemma
(ensures eta16 m == m) | let lemma_eta16 (#a:Type) (m:map16 a) =
let m1 = m in
let m2 = eta16 m in
assert_norm (get m1 0 == get m2 0);
assert_norm (get m1 1 == get m2 1);
assert_norm (get m1 2 == get m2 2);
assert_norm (get m1 3 == get m2 3);
assert_norm (get m1 4 == get m2 4);
assert_norm (get m1 5 == get m2 5);
... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 61,
"start_col": 0,
"start_line": 42
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m: Vale.Lib.Map16.map16 a -> FStar.Pervasives.Lemma (ensures Vale.Lib.Map16.eta16 m == m) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Vale.Lib.Map16.lemma_equal",
"Vale.Lib.Map16.eta16",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.Lib.Map16.get"
] | [] | true | false | true | false | false | let lemma_eta16 (#a: Type) (m: map16 a) =
| let m1 = m in
let m2 = eta16 m in
assert_norm (get m1 0 == get m2 0);
assert_norm (get m1 1 == get m2 1);
assert_norm (get m1 2 == get m2 2);
assert_norm (get m1 3 == get m2 3);
assert_norm (get m1 4 == get m2 4);
assert_norm (get m1 5 == get m2 5);
assert_norm (get m1 6 == get m2 6);
assert_norm (get m1 7 == get m2 7)... | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.init_rec | val init_rec (a: Type) (f: (i: nat{i < 16} -> a)) (n: nat)
: Pure (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i: nat). {:pattern sel m i} i < n ==> sel m i == f i) | val init_rec (a: Type) (f: (i: nat{i < 16} -> a)) (n: nat)
: Pure (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i: nat). {:pattern sel m i} i < n ==> sel m i == f i) | let rec init_rec (a:Type) (f:(i:nat{i < 16}) -> a) (n:nat) : Pure (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i:nat).{:pattern sel m i} i < n ==> sel m i == f i)
=
if n = 0 then
let m1 = f 0 in
let m4 = ((m1, m1), (m1, m1)) in
((m4, m4), (m4, m4))
else
upd (init_rec a f (n - 1)) (n ... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 85,
"start_col": 0,
"start_line": 76
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Val... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> f: (i: Prims.nat{i < 16} -> a) -> n: Prims.nat -> Prims.Pure (Vale.Lib.Map16.map16 a) | Prims.Pure | [] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Mktuple2",
"Vale.Lib.Map16.map8",
"Vale.Lib.Map16.map4",
"FStar.Pervasives.Native.tuple2",
"Vale.Lib.Map16.map2",
"Prims.bool",
"Vale.Lib.Map16.upd",
"Vale.Lib.Map16.init_rec",
"Prims.... | [
"recursion"
] | false | false | false | false | false | let rec init_rec (a: Type) (f: (i: nat{i < 16} -> a)) (n: nat)
: Pure (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i: nat). {:pattern sel m i} i < n ==> sel m i == f i) =
| if n = 0
then
let m1 = f 0 in
let m4 = ((m1, m1), (m1, m1)) in
((m4, m4), (m4, m4))
else upd (init_rec a f (n - 1)) (n - 1) (f (n - 1)) | false |
FStar.Pervasives.fst | FStar.Pervasives.delta_attr | val delta_attr (s: list string) : Tot norm_step | val delta_attr (s: list string) : Tot norm_step | let delta_attr s = UnfoldAttr s | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 110,
"start_col": 0,
"start_line": 110
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Prims.list Prims.string -> FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldAttr",
"FStar.Pervasives.norm_step"
] | [] | false | false | false | true | false | let delta_attr s =
| UnfoldAttr s | false |
FStar.Pervasives.fst | FStar.Pervasives.delta_fully | val delta_fully (s: list string) : Tot norm_step | val delta_fully (s: list string) : Tot norm_step | let delta_fully s = UnfoldFully s | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 107,
"start_col": 0,
"start_line": 107
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Prims.list Prims.string -> FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldFully",
"FStar.Pervasives.norm_step"
] | [] | false | false | false | true | false | let delta_fully s =
| UnfoldFully s | false |
FStar.Pervasives.fst | FStar.Pervasives.delta_qualifier | val delta_qualifier (s: list string) : Tot norm_step | val delta_qualifier (s: list string) : Tot norm_step | let delta_qualifier s = UnfoldAttr s | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 113,
"start_col": 0,
"start_line": 113
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Prims.list Prims.string -> FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldAttr",
"FStar.Pervasives.norm_step"
] | [] | false | false | false | true | false | let delta_qualifier s =
| UnfoldAttr s | false |
FStar.Pervasives.fst | FStar.Pervasives.unmeta | val unmeta : norm_step | val unmeta : norm_step | let unmeta = Unmeta | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 119,
"start_col": 0,
"start_line": 119
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Unmeta"
] | [] | false | false | false | true | false | let unmeta =
| Unmeta | false |
FStar.Pervasives.fst | FStar.Pervasives.norm | val norm (s: list norm_step) (#a: Type) (x: a) : Tot a | val norm (s: list norm_step) (#a: Type) (x: a) : Tot a | let norm _ #_ x = x | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 124,
"start_col": 0,
"start_line": 124
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Prims.list FStar.Pervasives.norm_step -> x: a -> a | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.norm_step"
] | [] | false | false | false | true | false | let norm _ #_ x =
| x | false |
FStar.Pervasives.fst | FStar.Pervasives.delta_namespace | val delta_namespace (s: list string) : Tot norm_step | val delta_namespace (s: list string) : Tot norm_step | let delta_namespace s = UnfoldNamespace s | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 116,
"start_col": 0,
"start_line": 116
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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: Prims.list Prims.string -> FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldNamespace",
"FStar.Pervasives.norm_step"
] | [] | false | false | false | true | false | let delta_namespace s =
| UnfoldNamespace s | false |
FStar.Pervasives.fst | FStar.Pervasives.unascribe | val unascribe : norm_step | val unascribe : norm_step | let unascribe = Unascribe | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 122,
"start_col": 0,
"start_line": 122
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | FStar.Pervasives.norm_step | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Unascribe"
] | [] | false | false | false | true | false | let unascribe =
| Unascribe | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_eta | val lemma_eta (#a:Type) (m:map16 a) : Lemma
(ensures eta m == m)
[SMTPat (eta m)] | val lemma_eta (#a:Type) (m:map16 a) : Lemma
(ensures eta m == m)
[SMTPat (eta m)] | let lemma_eta (#a:Type) (m:map16 a) =
assert_norm (eta m == eta16 m);
lemma_eta16 m | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 65,
"start_col": 0,
"start_line": 63
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m: Vale.Lib.Map16.map16 a
-> FStar.Pervasives.Lemma (ensures Vale.Lib.Map16.eta m == m) [SMTPat (Vale.Lib.Map16.eta m)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Vale.Lib.Map16.lemma_eta16",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.Lib.Map16.eta",
"Vale.Lib.Map16.eta16"
] | [] | true | false | true | false | false | let lemma_eta (#a: Type) (m: map16 a) =
| assert_norm (eta m == eta16 m);
lemma_eta16 m | false |
FStar.Pervasives.fst | FStar.Pervasives.inversion | val inversion (a: Type) : Type0 | val inversion (a: Type) : Type0 | let inversion _ = True | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 134,
"start_col": 0,
"start_line": 134
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.l_True"
] | [] | false | false | false | true | true | let inversion _ =
| True | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.lemma_equal_intro | val lemma_equal_intro (#a:Type) (m1 m2:map16 a) : Lemma
(requires (forall (i:int).{:pattern (sel m1 i) \/ (sel m2 i)} 0 <= i /\ i < 16 ==> sel m1 i == sel m2 i))
(ensures equal m1 m2)
[SMTPat (equal m1 m2)] | val lemma_equal_intro (#a:Type) (m1 m2:map16 a) : Lemma
(requires (forall (i:int).{:pattern (sel m1 i) \/ (sel m2 i)} 0 <= i /\ i < 16 ==> sel m1 i == sel m2 i))
(ensures equal m1 m2)
[SMTPat (equal m1 m2)] | let lemma_equal_intro #a m1 m2 =
lemma_equal m1 m2;
() | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 71,
"start_col": 0,
"start_line": 69
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"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 | m1: Vale.Lib.Map16.map16 a -> m2: Vale.Lib.Map16.map16 a
-> FStar.Pervasives.Lemma
(requires
forall (i: Prims.int). {:pattern Vale.Lib.Map16.sel m1 i\/Vale.Lib.Map16.sel m2 i}
0 <= i /\ i < 16 ==> Vale.Lib.Map16.sel m1 i == Vale.Lib.Map16.sel m2 i)
(ensures Vale.Lib.Map16.equal m1 m2)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Lib.Map16.map16",
"Prims.unit",
"Vale.Lib.Map16.lemma_equal"
] | [] | true | false | true | false | false | let lemma_equal_intro #a m1 m2 =
| lemma_equal m1 m2;
() | false |
Hacl.Streaming.Keccak.fst | Hacl.Streaming.Keccak.squeeze | val squeeze:
a:G.erased alg -> (
let c = hacl_keccak a in
let a = G.reveal a in
let i = a in
let t = sha3_state a in
let t' = G.erased unit in
s:state c i t t' ->
dst:B.buffer uint8 ->
l:Lib.IntTypes.size_t ->
Stack error_code
(requires fun h0 ->
(is_shake a ==> B.length dst == Lib.IntType... | val squeeze:
a:G.erased alg -> (
let c = hacl_keccak a in
let a = G.reveal a in
let i = a in
let t = sha3_state a in
let t' = G.erased unit in
s:state c i t t' ->
dst:B.buffer uint8 ->
l:Lib.IntTypes.size_t ->
Stack error_code
(requires fun h0 ->
(is_shake a ==> B.length dst == Lib.IntType... | let squeeze a s dst l =
let a = get_alg a s in
if not (a = Shake128 || a = Shake256) then
InvalidAlgorithm
else if l = 0ul then
InvalidLength
else begin
digest_ a s dst l;
Success
end | {
"file_name": "code/streaming/Hacl.Streaming.Keccak.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 305,
"start_col": 0,
"start_line": 296
} | module Hacl.Streaming.Keccak
open FStar.HyperStack.ST
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module F = Hacl.Streaming.Functor
module ST = FStar.Hy... | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Lemmas.fsti.checked",
"Spec.Hash.Incremental.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.... | [
{
"abbrev": false,
"full_module": "Hacl.Streaming.Functor",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Agile"
},
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "D"
},
{
"abbrev": false,
... | {
"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 | a: FStar.Ghost.erased Hacl.Streaming.Keccak.alg
-> (let c = Hacl.Streaming.Keccak.hacl_keccak a in
let a = FStar.Ghost.reveal a in
let i = a in
let t = Hacl.Streaming.Keccak.sha3_state a in
let t' = FStar.Ghost.erased Prims.unit in
s: Hacl.Streaming.Functor.state c i t t' ->
... | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"Hacl.Streaming.Keccak.alg",
"Hacl.Streaming.Functor.state",
"Hacl.Streaming.Keccak.hacl_keccak",
"FStar.Ghost.reveal",
"Hacl.Streaming.Keccak.sha3_state",
"Prims.unit",
"LowStar.Buffer.buffer",
"Hacl.Streaming.Functor.uint8",
"Lib.IntTypes.size_t",
"Prims.op_Negation",
"... | [] | false | false | false | false | false | let squeeze a s dst l =
| let a = get_alg a s in
if not (a = Shake128 || a = Shake256)
then InvalidAlgorithm
else
if l = 0ul
then InvalidLength
else
(digest_ a s dst l;
Success) | false |
Hacl.Streaming.Keccak.fst | Hacl.Streaming.Keccak.digest | val digest:
a:G.erased alg -> (
let c = hacl_keccak a in
let a = G.reveal a in
let i = a in
let t = sha3_state a in
let t' = G.erased unit in
s:state c i t t' ->
dst:B.buffer uint8 ->
Stack error_code
(requires fun h0 ->
(not (is_shake a) ==> B.length dst == Spec.Hash.Definitions.hash_length... | val digest:
a:G.erased alg -> (
let c = hacl_keccak a in
let a = G.reveal a in
let i = a in
let t = sha3_state a in
let t' = G.erased unit in
s:state c i t t' ->
dst:B.buffer uint8 ->
Stack error_code
(requires fun h0 ->
(not (is_shake a) ==> B.length dst == Spec.Hash.Definitions.hash_length... | let digest a state output =
let a = get_alg a state in
if (a = Shake128 || a = Shake256) then
InvalidAlgorithm
else begin
digest_ a state output (Hacl.Hash.SHA3.hash_len a);
Success
end | {
"file_name": "code/streaming/Hacl.Streaming.Keccak.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 256,
"start_col": 0,
"start_line": 249
} | module Hacl.Streaming.Keccak
open FStar.HyperStack.ST
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module F = Hacl.Streaming.Functor
module ST = FStar.Hy... | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Lemmas.fsti.checked",
"Spec.Hash.Incremental.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.... | [
{
"abbrev": false,
"full_module": "Hacl.Streaming.Functor",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Agile"
},
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "D"
},
{
"abbrev": false,
... | {
"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 | a: FStar.Ghost.erased Hacl.Streaming.Keccak.alg
-> (let c = Hacl.Streaming.Keccak.hacl_keccak a in
let a = FStar.Ghost.reveal a in
let i = a in
let t = Hacl.Streaming.Keccak.sha3_state a in
let t' = FStar.Ghost.erased Prims.unit in
s: Hacl.Streaming.Functor.state c i t t' ->
... | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"Hacl.Streaming.Keccak.alg",
"Hacl.Streaming.Functor.state",
"Hacl.Streaming.Keccak.hacl_keccak",
"FStar.Ghost.reveal",
"Hacl.Streaming.Keccak.sha3_state",
"Prims.unit",
"LowStar.Buffer.buffer",
"Hacl.Streaming.Functor.uint8",
"Prims.op_BarBar",
"Prims.op_Equality",
"Spec... | [] | false | false | false | false | false | let digest a state output =
| let a = get_alg a state in
if (a = Shake128 || a = Shake256)
then InvalidAlgorithm
else
(digest_ a state output (Hacl.Hash.SHA3.hash_len a);
Success) | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.init | val init (a:Type) (f:(i:nat{i < 16}) -> a) : Pure (map16 a)
(requires True)
(ensures fun m -> forall (i:int).{:pattern (sel m i)} 0 <= i /\ i < 16 ==> sel m i == f i) | val init (a:Type) (f:(i:nat{i < 16}) -> a) : Pure (map16 a)
(requires True)
(ensures fun m -> forall (i:int).{:pattern (sel m i)} 0 <= i /\ i < 16 ==> sel m i == f i) | let init a f =
init_rec a f 16 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 88,
"start_col": 0,
"start_line": 87
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> f: (i: Prims.nat{i < 16} -> a) -> Prims.Pure (Vale.Lib.Map16.map16 a) | Prims.Pure | [] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Lib.Map16.init_rec",
"Vale.Lib.Map16.map16"
] | [] | false | false | false | false | false | let init a f =
| init_rec a f 16 | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.init_ghost | val init_ghost (a:Type) (f:(i:nat{i < 16}) -> GTot a) : Ghost (map16 a)
(requires True)
(ensures fun m -> forall (i:int).{:pattern (sel m i)} 0 <= i /\ i < 16 ==> sel m i == f i) | val init_ghost (a:Type) (f:(i:nat{i < 16}) -> GTot a) : Ghost (map16 a)
(requires True)
(ensures fun m -> forall (i:int).{:pattern (sel m i)} 0 <= i /\ i < 16 ==> sel m i == f i) | let init_ghost a f =
init_ghost_rec a f 16 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 102,
"start_col": 0,
"start_line": 101
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> f: (i: Prims.nat{i < 16} -> Prims.GTot a) -> Prims.Ghost (Vale.Lib.Map16.map16 a) | Prims.Ghost | [] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Lib.Map16.init_ghost_rec",
"Vale.Lib.Map16.map16"
] | [] | false | false | false | false | false | let init_ghost a f =
| init_ghost_rec a f 16 | false |
Hacl.Impl.P256.Bignum.fsti | Hacl.Impl.P256.Bignum.wide_as_nat | val wide_as_nat (h: mem) (e: widefelem) : GTot nat | val wide_as_nat (h: mem) (e: widefelem) : GTot nat | let wide_as_nat (h:mem) (e:widefelem) : GTot nat =
BD.bn_v (as_seq h e) | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 28,
"start_col": 0,
"start_line": 27
} | module Hacl.Impl.P256.Bignum
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module BD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.ch... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
... | {
"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 | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.P256.Bignum.widefelem -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Bignum.widefelem",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.size",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.nat"
] | [] | false | false | false | false | false | let wide_as_nat (h: mem) (e: widefelem) : GTot nat =
| BD.bn_v (as_seq h e) | false |
Vale.Lib.Map16.fst | Vale.Lib.Map16.init_ghost_rec | val init_ghost_rec (a: Type) (f: (i: nat{i < 16} -> GTot a)) (n: nat)
: Ghost (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i: nat). {:pattern sel m i} i < n ==> sel m i == f i) | val init_ghost_rec (a: Type) (f: (i: nat{i < 16} -> GTot a)) (n: nat)
: Ghost (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i: nat). {:pattern sel m i} i < n ==> sel m i == f i) | let rec init_ghost_rec (a:Type) (f:(i:nat{i < 16}) -> GTot a) (n:nat) : Ghost (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i:nat).{:pattern sel m i} i < n ==> sel m i == f i)
=
if n = 0 then
let m1 = f 0 in
let m4 = ((m1, m1), (m1, m1)) in
((m4, m4), (m4, m4))
else
upd (init_ghost_re... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 99,
"start_col": 0,
"start_line": 90
} | module Vale.Lib.Map16
open FStar.Mul
let lemma_self16 (#a:Type) (m:map16 a) (n:int) (v:a) = ()
let lemma_other16 (#a:Type) (m:map16 a) (n1 n2:int) (v:a) = ()
#reset-options "--initial_ifuel 5 --max_ifuel 5"
let lemma_equal16 (#a:Type) (m1 m2:map16 a) =
assert (sel16 m1 0 == sel16 m2 0);
assert (sel16 m1 1 == s... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Map16.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Val... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> f: (i: Prims.nat{i < 16} -> Prims.GTot a) -> n: Prims.nat
-> Prims.Ghost (Vale.Lib.Map16.map16 a) | Prims.Ghost | [] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Mktuple2",
"Vale.Lib.Map16.map8",
"Vale.Lib.Map16.map4",
"FStar.Pervasives.Native.tuple2",
"Vale.Lib.Map16.map2",
"Prims.bool",
"Vale.Lib.Map16.upd",
"Vale.Lib.Map16.init_ghost_rec",
"... | [
"recursion"
] | false | false | false | false | false | let rec init_ghost_rec (a: Type) (f: (i: nat{i < 16} -> GTot a)) (n: nat)
: Ghost (map16 a)
(requires n <= 16)
(ensures fun m -> forall (i: nat). {:pattern sel m i} i < n ==> sel m i == f i) =
| if n = 0
then
let m1 = f 0 in
let m4 = ((m1, m1), (m1, m1)) in
((m4, m4), (m4, m4))
else upd (init_ghost_rec a f (n - 1)) (n - 1) (f (n - 1)) | false |
Hacl.Impl.P256.Bignum.fsti | Hacl.Impl.P256.Bignum.widefelem | val widefelem : Type0 | let widefelem = lbuffer uint64 (size 8) | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | module Hacl.Impl.P256.Bignum
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module BD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.ch... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
... | {
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size"
] | [] | false | false | false | true | true | let widefelem =
| lbuffer uint64 (size 8) | false | |
FStar.Pervasives.fst | FStar.Pervasives.false_elim | val false_elim (#a: Type) (u: unit{False}) : Tot a | val false_elim (#a: Type) (u: unit{False}) : Tot a | let rec false_elim #_ _ = false_elim () | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 140,
"start_col": 0,
"start_line": 140
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"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 | u930: u931: Prims.unit{Prims.l_False} -> a | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.l_False",
"FStar.Pervasives.false_elim"
] | [
"recursion"
] | false | false | false | false | false | let rec false_elim #_ _ =
| false_elim () | false |
Hacl.Impl.P256.Bignum.fsti | Hacl.Impl.P256.Bignum.as_nat | val as_nat (h: mem) (e: felem) : GTot nat | val as_nat (h: mem) (e: felem) : GTot nat | let as_nat (h:mem) (e:felem) : GTot nat =
BD.bn_v (as_seq h e) | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 24,
"start_col": 0,
"start_line": 23
} | module Hacl.Impl.P256.Bignum
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module BD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.ch... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
... | {
"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 | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.P256.Bignum.felem -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.size",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.nat"
] | [] | false | false | false | false | false | let as_nat (h: mem) (e: felem) : GTot nat =
| BD.bn_v (as_seq h e) | false |
FStar.Pervasives.fst | FStar.Pervasives.singleton | val singleton (#a: Type) (x: a) : Tot (y: a{y == x}) | val singleton (#a: Type) (x: a) : Tot (y: a{y == x}) | let singleton #_ x = x | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 200,
"start_col": 0,
"start_line": 200
} | (*
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"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> y: a{y == x} | Prims.Tot | [
"total"
] | [] | [
"Prims.eq2"
] | [] | false | false | false | false | false | let singleton #_ x =
| x | false |
Hacl.Impl.P256.Bignum.fsti | Hacl.Impl.P256.Bignum.felem | val felem : Type0 | let felem = lbuffer uint64 (size 4) | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 18,
"start_col": 0,
"start_line": 18
} | module Hacl.Impl.P256.Bignum
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module BD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.ch... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
... | {
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size"
] | [] | false | false | false | true | true | let felem =
| lbuffer uint64 (size 4) | false | |
Hacl.Streaming.Keccak.fst | Hacl.Streaming.Keccak.hacl_keccak | val hacl_keccak (a: G.erased alg) : block alg | val hacl_keccak (a: G.erased alg) : block alg | let hacl_keccak (a: G.erased alg): block alg =
Block
Erased
stateful_keccak (* state *)
(stateful_unused alg) (* key *)
Lib.IntTypes.(x:size_t { v x > 0 }) (* output_length_t *)
(fun _ ->
[@inline_let]
let max = Lib.IntTypes.(ones U64 PUB) in
assert (forall (a: alg). Hacl.Hash.D... | {
"file_name": "code/streaming/Hacl.Streaming.Keccak.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 185,
"start_col": 0,
"start_line": 121
} | module Hacl.Streaming.Keccak
open FStar.HyperStack.ST
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module F = Hacl.Streaming.Functor
module ST = FStar.Hy... | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Lemmas.fsti.checked",
"Spec.Hash.Incremental.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.... | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Agile"
},
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "D"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming.Interface",
"short_module": null
},
{
"abbrev": false,... | {
"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 | a: FStar.Ghost.erased Hacl.Streaming.Keccak.alg
-> Hacl.Streaming.Interface.block Hacl.Streaming.Keccak.alg | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"Hacl.Streaming.Keccak.alg",
"Hacl.Streaming.Interface.Block",
"Hacl.Streaming.Interface.Erased",
"Hacl.Streaming.Keccak.stateful_keccak",
"Hacl.Streaming.Interface.stateful_unused",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes... | [] | false | false | false | true | false | let hacl_keccak (a: G.erased alg) : block alg =
| Block Erased
stateful_keccak
(stateful_unused alg)
Lib.IntTypes.(x: size_t{v x > 0})
(fun _ ->
[@@ inline_let ]let max = let open Lib.IntTypes in ones U64 PUB in
assert (forall (a: alg). Hacl.Hash.Definitions.max_input_len64 a == max);
max)
(fun a l -> if is_shake_ a then Lib.IntTypes.v l el... | false |
Steel.MonotonicCounter.fst | Steel.MonotonicCounter.increasing | val increasing:preorder nat | val increasing:preorder nat | let increasing : preorder nat = fun (x y:nat) -> b2t (x <= y) | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 61,
"end_line": 42,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Steel.MonotonicCounter.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | {
"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 | FStar.Preorder.preorder Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.logical"
] | [] | false | false | false | true | false | let increasing:preorder nat =
| fun (x: nat) (y: nat) -> b2t (x <= y) | false |
Steel.MonotonicCounter.fst | Steel.MonotonicCounter.mctr_induces_increases | val mctr_induces_increases:squash (induces_preorder mctr_pcm increasing) | val mctr_induces_increases:squash (induces_preorder mctr_pcm increasing) | let mctr_induces_increases
: squash (induces_preorder mctr_pcm increasing)
= let aux (x y:nat) (f:frame_preserving_upd mctr_pcm x y) (v:nat)
: Lemma (requires compatible mctr_pcm x v)
(ensures increasing v (f v))
[SMTPat ()]
= assert (composable mctr_pcm x v)
in
() | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 6,
"end_line": 54,
"start_col": 0,
"start_line": 46
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Steel.MonotonicCounter.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | {
"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.squash (Steel.Preorder.induces_preorder Steel.MonotonicCounter.mctr_pcm
Steel.MonotonicCounter.increasing) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.PCM.frame_preserving_upd",
"Steel.MonotonicCounter.mctr_pcm",
"Prims.unit",
"FStar.PCM.compatible",
"Prims.squash",
"Steel.MonotonicCounter.increasing",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil",
"Prims._assert",
"FStar.PCM.composab... | [] | false | false | true | true | false | let mctr_induces_increases:squash (induces_preorder mctr_pcm increasing) =
| let aux (x y: nat) (f: frame_preserving_upd mctr_pcm x y) (v: nat)
: Lemma (requires compatible mctr_pcm x v) (ensures increasing v (f v)) [SMTPat ()] =
assert (composable mctr_pcm x v)
in
() | false |
Steel.MonotonicCounter.fst | Steel.MonotonicCounter.test | val test (x z: nat) (f: (nat -> prop){stable f increasing})
: Lemma (requires (compatible mctr_pcm x z /\ f x)) (ensures f z) | val test (x z: nat) (f: (nat -> prop){stable f increasing})
: Lemma (requires (compatible mctr_pcm x z /\ f x)) (ensures f z) | let test (x z:nat) (f:(nat -> prop){stable f increasing})
: Lemma
(requires (compatible mctr_pcm x z /\ f x))
(ensures f z)
= assert (increasing x z) | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 27,
"end_line": 62,
"start_col": 0,
"start_line": 58
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Steel.MonotonicCounter.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: Prims.nat ->
z: Prims.nat ->
f: (_: Prims.nat -> Prims.prop){FStar.Preorder.stable f Steel.MonotonicCounter.increasing}
-> FStar.Pervasives.Lemma
(requires FStar.PCM.compatible Steel.MonotonicCounter.mctr_pcm x z /\ f x) (ensures f z) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.prop",
"FStar.Preorder.stable",
"Steel.MonotonicCounter.increasing",
"Prims._assert",
"Prims.unit",
"Prims.l_and",
"FStar.PCM.compatible",
"Steel.MonotonicCounter.mctr_pcm",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let test (x z: nat) (f: (nat -> prop){stable f increasing})
: Lemma (requires (compatible mctr_pcm x z /\ f x)) (ensures f z) =
| assert (increasing x z) | false |
Steel.MonotonicCounter.fst | Steel.MonotonicCounter.pre_pcm | val pre_pcm:pcm' nat | val pre_pcm:pcm' nat | let pre_pcm : pcm' nat = {
composable=(fun x y -> True);
op=(fun (x y:nat) -> Math.Lib.max x y);
one=0
} | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 1,
"end_line": 31,
"start_col": 0,
"start_line": 27
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Steel.MonotonicCounter.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | {
"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 | FStar.PCM.pcm' Prims.nat | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.Mkpcm'",
"Prims.nat",
"Prims.l_True",
"Prims.prop",
"FStar.Math.Lib.max"
] | [] | false | false | false | true | false | let pre_pcm:pcm' nat =
| { composable = (fun x y -> True); op = (fun (x: nat) (y: nat) -> Math.Lib.max x y); one = 0 } | false |
Steel.MonotonicCounter.fst | Steel.MonotonicCounter.mctr_pcm | val mctr_pcm:pcm nat | val mctr_pcm:pcm nat | let mctr_pcm : pcm nat = {
p=pre_pcm;
comm=(fun _ _ -> ());
assoc=(fun _ _ _ -> ());
assoc_r=(fun _ _ _ -> ());
is_unit=(fun _ -> ());
refine=(fun _ -> True);
} | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 1,
"end_line": 39,
"start_col": 0,
"start_line": 32
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Steel.MonotonicCounter.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | {
"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 | FStar.PCM.pcm Prims.nat | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.Mkpcm",
"Prims.nat",
"Steel.MonotonicCounter.pre_pcm",
"FStar.PCM.__proj__Mkpcm'__item__composable",
"Prims.unit",
"Prims.l_and",
"FStar.PCM.__proj__Mkpcm'__item__op",
"Prims.l_True",
"Prims.prop"
] | [] | false | false | false | true | false | let mctr_pcm:pcm nat =
| {
p = pre_pcm;
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | false |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.pred2 | val pred2 : x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | let pred2 (x y z : nat) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 47,
"start_col": 0,
"start_line": 47
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let pred2 (x y z: nat) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.lpred1 | val lpred1 : l1: FStar.Seq.Base.seq Prims.int -> l2: FStar.Seq.Base.seq Prims.int -> Prims.logical | let lpred1 (l1 l2 : Seq.seq int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 53,
"start_col": 0,
"start_line": 53
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | l1: FStar.Seq.Base.seq Prims.int -> l2: FStar.Seq.Base.seq Prims.int -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let lpred1 (l1 l2: Seq.seq int) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.pred3 | val pred3 : x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | let pred3 (x y z : nat) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 48,
"start_col": 0,
"start_line": 48
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let pred3 (x y z: nat) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.pred5 | val pred5 : x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | let pred5 (x y z : nat) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 50,
"start_col": 0,
"start_line": 50
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let pred5 (x y z: nat) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.pred1 | val pred1 : x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | let pred1 (x y z : nat) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 46,
"start_col": 0,
"start_line": 46
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let pred1 (x y z: nat) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.pred6 | val pred6 : x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | let pred6 (x y z : nat) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 51,
"start_col": 0,
"start_line": 51
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let pred6 (x y z: nat) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.lpred3 | val lpred3 : l1: FStar.Seq.Base.seq Prims.int -> l2: FStar.Seq.Base.seq Prims.int -> Prims.logical | let lpred3 (l1 l2 : Seq.seq int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 55,
"start_col": 0,
"start_line": 55
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | l1: FStar.Seq.Base.seq Prims.int -> l2: FStar.Seq.Base.seq Prims.int -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let lpred3 (l1 l2: Seq.seq int) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.lpred2 | val lpred2 : l1: FStar.Seq.Base.seq Prims.int -> l2: FStar.Seq.Base.seq Prims.int -> Prims.logical | let lpred2 (l1 l2 : Seq.seq int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 54,
"start_col": 0,
"start_line": 54
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | l1: FStar.Seq.Base.seq Prims.int -> l2: FStar.Seq.Base.seq Prims.int -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let lpred2 (l1 l2: Seq.seq int) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.spred1 | val spred1 : h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | let spred1 (h : HS.mem) (r1 r2 r3 : B.buffer int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 57,
"start_col": 0,
"start_line": 57
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 |
h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let spred1 (h: HS.mem) (r1 r2 r3: B.buffer int) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.pred4 | val pred4 : x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | let pred4 (x y z : nat) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 49,
"start_col": 0,
"start_line": 49
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> z: Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let pred4 (x y z: nat) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.spred3 | val spred3 : h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | let spred3 (h : HS.mem) (r1 r2 r3 : B.buffer int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 |
h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let spred3 (h: HS.mem) (r1 r2 r3: B.buffer int) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.spred4 | val spred4 : h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | let spred4 (h : HS.mem) (r1 r2 r3 : B.buffer int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 60,
"start_col": 0,
"start_line": 60
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 |
h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let spred4 (h: HS.mem) (r1 r2 r3: B.buffer int) =
| True | false | |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.spred2 | val spred2 : h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | let spred2 (h : HS.mem) (r1 r2 r3 : B.buffer int) = True | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 58,
"start_col": 0,
"start_line": 58
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 |
h: FStar.Monotonic.HyperStack.mem ->
r1: LowStar.Buffer.buffer Prims.int ->
r2: LowStar.Buffer.buffer Prims.int ->
r3: LowStar.Buffer.buffer Prims.int
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"Prims.int",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let spred2 (h: HS.mem) (r1 r2 r3: B.buffer int) =
| True | false | |
FStar.Preorder.fst | FStar.Preorder.reflexive | val reflexive : rel: FStar.Preorder.relation a -> Prims.logical | let reflexive (#a:Type) (rel:relation a) =
forall (x:a). rel x x | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 25,
"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.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"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 | rel: FStar.Preorder.relation a -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.relation",
"Prims.l_Forall",
"Prims.logical"
] | [] | false | false | false | true | true | let reflexive (#a: Type) (rel: relation a) =
| forall (x: a). rel x x | false | |
FStar.Preorder.fst | FStar.Preorder.transitive | val transitive : rel: FStar.Preorder.relation a -> Prims.logical | let transitive (#a:Type) (rel:relation a) =
forall (x:a) (y:a) (z:a). (rel x y /\ rel y z) ==> rel x z | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 28,
"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.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"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 | rel: FStar.Preorder.relation a -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.relation",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.logical"
] | [] | false | false | false | true | true | let transitive (#a: Type) (rel: relation a) =
| forall (x: a) (y: a) (z: a). (rel x y /\ rel y z) ==> rel x z | false | |
FStar.Preorder.fst | FStar.Preorder.preorder_rel | val preorder_rel : rel: FStar.Preorder.relation a -> Prims.logical | let preorder_rel (#a:Type) (rel:relation a) =
reflexive rel /\ transitive rel | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 31,
"start_col": 0,
"start_line": 30
} | (*
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.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"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 | rel: FStar.Preorder.relation a -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.relation",
"Prims.l_and",
"FStar.Preorder.reflexive",
"FStar.Preorder.transitive",
"Prims.logical"
] | [] | false | false | false | true | true | let preorder_rel (#a: Type) (rel: relation a) =
| reflexive rel /\ transitive rel | false | |
FStar.Preorder.fst | FStar.Preorder.stable | val stable : p: FStar.Preorder.predicate a -> rel: FStar.Preorder.relation a {FStar.Preorder.preorder_rel rel}
-> Prims.logical | let stable (#a:Type) (p:predicate a) (rel:relation a{preorder_rel rel}) =
forall (x:a) (y:a). (p x /\ rel x y) ==> p y | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 36,
"start_col": 0,
"start_line": 35
} | (*
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.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: FStar.Preorder.predicate a -> rel: FStar.Preorder.relation a {FStar.Preorder.preorder_rel rel}
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.predicate",
"FStar.Preorder.relation",
"FStar.Preorder.preorder_rel",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.logical"
] | [] | false | false | false | false | true | let stable (#a: Type) (p: predicate a) (rel: relation a {preorder_rel rel}) =
| forall (x: a) (y: a). (p x /\ rel x y) ==> p y | false | |
LowParse.SLow.List.fst | LowParse.SLow.List.list_rev_inv | val list_rev_inv (#t: Type) (l: list t) (b: bool) (x: (list t * list t)) : GTot Type0 | val list_rev_inv (#t: Type) (l: list t) (b: bool) (x: (list t * list t)) : GTot Type0 | let list_rev_inv
(#t: Type)
(l: list t)
(b: bool)
(x: list t * list t)
: GTot Type0
= let (rem, acc) = x in
L.rev l == L.rev_acc rem acc /\
(b == false ==> rem == []) | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 100,
"start_col": 0,
"start_line": 92
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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.list t -> b: Prims.bool -> x: (Prims.list t * Prims.list t) -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"Prims.l_and",
"Prims.eq2",
"FStar.List.Tot.Base.rev",
"FStar.List.Tot.Base.rev_acc",
"Prims.l_imp",
"Prims.Nil"
] | [] | false | false | false | false | true | let list_rev_inv (#t: Type) (l: list t) (b: bool) (x: list t * list t) : GTot Type0 =
| let rem, acc = x in
L.rev l == L.rev_acc rem acc /\ (b == false ==> rem == []) | false |
LowParse.SLow.List.fst | LowParse.SLow.List.partial_serialize32_list'_measure | val partial_serialize32_list'_measure (#t: Type) (x: (bytes32 * list t)) : GTot nat | val partial_serialize32_list'_measure (#t: Type) (x: (bytes32 * list t)) : GTot nat | let partial_serialize32_list'_measure
(#t: Type)
(x: bytes32 * list t)
: GTot nat
= L.length (snd x) | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 296,
"start_col": 0,
"start_line": 292
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: (LowParse.SLow.Base.bytes32 * Prims.list t) -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"LowParse.SLow.Base.bytes32",
"Prims.list",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.snd",
"Prims.nat"
] | [] | false | false | false | false | false | let partial_serialize32_list'_measure (#t: Type) (x: bytes32 * list t) : GTot nat =
| L.length (snd x) | false |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.f4 | val f4 (n: int{n % 2 = 0}) : Tot (n': int{n' % 2 = 0}) | val f4 (n: int{n % 2 = 0}) : Tot (n': int{n' % 2 = 0}) | let f4 (n : int{n % 2 = 0}) : Tot (n':int{n' % 2 = 0}) =
n + 2 | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 26,
"start_col": 0,
"start_line": 25
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | n: Prims.int{n % 2 = 0} -> n': Prims.int{n' % 2 = 0} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_Modulus",
"Prims.op_Addition"
] | [] | false | false | false | false | false | let f4 (n: int{n % 2 = 0}) : Tot (n': int{n' % 2 = 0}) =
| n + 2 | false |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.f1 | val f1 (n: int) (m: nat) : Pure nat (requires (n > 3)) (ensures (fun _ -> True)) | val f1 (n: int) (m: nat) : Pure nat (requires (n > 3)) (ensures (fun _ -> True)) | let f1 (n : int) (m : nat) : Pure nat (requires (n > 3)) (ensures (fun _ -> True)) =
m % (n - 3) | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 16,
"start_col": 0,
"start_line": 15
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | n: Prims.int -> m: Prims.nat -> Prims.Pure Prims.nat | Prims.Pure | [] | [] | [
"Prims.int",
"Prims.nat",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_True"
] | [] | false | false | false | false | false | let f1 (n: int) (m: nat) : Pure nat (requires (n > 3)) (ensures (fun _ -> True)) =
| m % (n - 3) | false |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.f2 | val f2 (x y: nat) : Pure (z: nat{z >= 8}) (requires True) (ensures (fun z -> z % 2 = 0)) | val f2 (x y: nat) : Pure (z: nat{z >= 8}) (requires True) (ensures (fun z -> z % 2 = 0)) | let f2 (x y : nat) :
Pure (z:nat{z >= 8}) (requires True) (ensures (fun z -> z % 2 = 0)) =
2 * (x + y) + 8 | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 20,
"start_col": 0,
"start_line": 18
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> y: Prims.nat -> Prims.Pure (z: Prims.nat{z >= 8}) | Prims.Pure | [] | [] | [
"Prims.nat",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.l_True",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus"
] | [] | false | false | false | false | false | let f2 (x y: nat) : Pure (z: nat{z >= 8}) (requires True) (ensures (fun z -> z % 2 = 0)) =
| 2 * (x + y) + 8 | false |
FStar.InteractiveHelpers.Tutorial.Definitions.fst | FStar.InteractiveHelpers.Tutorial.Definitions.f3 | val f3 (x: nat) : nat | val f3 (x: nat) : nat | let f3 (x : nat) : nat =
2 * x | {
"file_name": "examples/interactive/FStar.InteractiveHelpers.Tutorial.Definitions.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module FStar.InteractiveHelpers.Tutorial.Definitions
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
open FStar.List
open FStar.Tactics.V2
open FStar.Mul
/// Some dummy functions used for the tutorial for the FStar.FStar.InteractiveHelpers functions
#push-options "--z3rlimit 5... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowSt... | {
"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 | x: Prims.nat -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Mul.op_Star"
] | [] | false | false | false | true | false | let f3 (x: nat) : nat =
| 2 * x | false |
LowParse.SLow.List.fst | LowParse.SLow.List.size32_list_measure | val size32_list_measure (#t: Type) (accu: (U32.t * list t)) : GTot nat | val size32_list_measure (#t: Type) (accu: (U32.t * list t)) : GTot nat | let size32_list_measure
(#t: Type)
(accu: (U32.t * list t))
: GTot nat
= let (_, rem) = accu in
L.length rem | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 394,
"start_col": 0,
"start_line": 389
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 | accu: (FStar.UInt32.t * Prims.list t) -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"Prims.list",
"FStar.List.Tot.Base.length",
"Prims.nat"
] | [] | false | false | false | false | false | let size32_list_measure (#t: Type) (accu: (U32.t * list t)) : GTot nat =
| let _, rem = accu in
L.length rem | false |
Spec.Curve25519.Lemmas.fst | Spec.Curve25519.Lemmas.lemma_prime_value | val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed))
[SMTPat (pow2 n - 19)] | val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed))
[SMTPat (pow2 n - 19)] | let lemma_prime_value n = assert_norm(pow2 255 - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed) | {
"file_name": "specs/lemmas/Spec.Curve25519.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 121,
"end_line": 7,
"start_col": 0,
"start_line": 7
} | module Spec.Curve25519.Lemmas
val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.Curve25519.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat
-> FStar.Pervasives.Lemma (requires n = 255)
(ensures
Prims.pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed)
[SMTPat (Prims.pow2 n - 19)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_prime_value n =
| assert_norm (pow2 255 - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed) | false |
Spec.Curve25519.Lemmas.fst | Spec.Curve25519.Lemmas.lemma_pow2_256 | val lemma_pow2_256: n:nat -> Lemma
(requires (n = 256))
(ensures (pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000))
[SMTPat (pow2 n)] | val lemma_pow2_256: n:nat -> Lemma
(requires (n = 256))
(ensures (pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000))
[SMTPat (pow2 n)] | let lemma_pow2_256 n = assert_norm(pow2 256 = 0x10000000000000000000000000000000000000000000000000000000000000000) | {
"file_name": "specs/lemmas/Spec.Curve25519.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 114,
"end_line": 19,
"start_col": 0,
"start_line": 19
} | module Spec.Curve25519.Lemmas
val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed))
[SMTPat (pow2 n - 19)]
let lemma_prime_value n = assert_norm(pow2 255 - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffff... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.Curve25519.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat
-> FStar.Pervasives.Lemma (requires n = 256)
(ensures Prims.pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000)
[SMTPat (Prims.pow2 n)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_pow2_256 n =
| assert_norm (pow2 256 = 0x10000000000000000000000000000000000000000000000000000000000000000) | false |
MerkleTree.New.High.Correct.Flushing.fst | MerkleTree.New.High.Correct.Flushing.mt_flush_inv_preserved | val mt_flush_inv_preserved:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt /\ MT?.j mt > MT?.i mt} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
Lemma (requires (mt_inv mt olds))
(ensures (mt_inv (mt_flush mt)
(mt_flush_to_olds #_ #(MT?.hash_... | val mt_flush_inv_preserved:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt /\ MT?.j mt > MT?.i mt} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
Lemma (requires (mt_inv mt olds))
(ensures (mt_inv (mt_flush mt)
(mt_flush_to_olds #_ #(MT?.hash_... | let mt_flush_inv_preserved #hsz mt olds =
mt_flush_to_inv_preserved #hsz mt olds (MT?.j mt - 1) | {
"file_name": "src/MerkleTree.New.High.Correct.Flushing.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 55,
"end_line": 161,
"start_col": 0,
"start_line": 160
} | module MerkleTree.New.High.Correct.Flushing
open EverCrypt
open EverCrypt.Helpers
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module List = FStar.List.Tot
module S = FStar.Seq
module U32 = FStar.UInt32
module U8 = FStar.UInt8
type uint32_t = U32.t
type uint8_t = U8.t
module EHS = EverCrypt.Hash
module MTS... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.Correct.Base.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.che... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High.Correct.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": ... | {
"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 |
mt: MerkleTree.New.High.merkle_tree{MerkleTree.New.High.mt_wf_elts mt /\ MT?.j mt > MT?.i mt} ->
olds:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length olds = 32 /\
MerkleTree.New.High.Correct.Base.mt_olds_inv 0 (MT?.i mt) olds }
-> FStar.Pervasives.Lemma (requires MerkleTree.New.H... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.New.High.merkle_tree",
"Prims.l_and",
"MerkleTree.New.High.mt_wf_elts",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.__proj__MT__item__j",
"MerkleTree.New.High.__proj__MT__item__i",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Se... | [] | true | false | true | false | false | let mt_flush_inv_preserved #hsz mt olds =
| mt_flush_to_inv_preserved #hsz mt olds (MT?.j mt - 1) | false |
LowParse.SLow.List.fst | LowParse.SLow.List.parse_list_tailrec_inv | val parse_list_tailrec_inv
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(b: bool)
(x: option (bytes32 * list t))
: GTot Type0 | val parse_list_tailrec_inv
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(b: bool)
(x: option (bytes32 * list t))
: GTot Type0 | let parse_list_tailrec_inv
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(b: bool)
(x: option (bytes32 * list t))
: GTot Type0
= match x with
| Some (input', accu') ->
parse_list_tailrec' p32 input [] == parse_list_tailrec' p32 input' accu' /\
(b == false ==> B... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 58,
"end_line": 136,
"start_col": 0,
"start_line": 122
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 |
p32: LowParse.SLow.Base.parser32 p ->
input: LowParse.SLow.Base.bytes32 ->
b: Prims.bool ->
x: FStar.Pervasives.Native.option (LowParse.SLow.Base.bytes32 * Prims.list t)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"Prims.bool",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"Prims.l_and",
"Prims.eq2",
"LowParse.SLow.List.parse_list_tailrec'",
"Pri... | [] | false | false | false | false | true | let parse_list_tailrec_inv
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(b: bool)
(x: option (bytes32 * list t))
: GTot Type0 =
| match x with
| Some (input', accu') ->
parse_list_tailrec' p32 input [] == parse_list_tailrec' p32 input' accu' /\
(b == false ==> B32.length input' == 0)
| None -> b == false /\ None? (parse_list_tailrec' p32 input []) | false |
LowParse.SLow.List.fst | LowParse.SLow.List.list_append_rev_cons | val list_append_rev_cons (#t: Type) (v: t) (aux l: list t)
: Lemma (L.append (L.rev (v :: aux)) l == L.append (L.rev aux) (v :: l)) | val list_append_rev_cons (#t: Type) (v: t) (aux l: list t)
: Lemma (L.append (L.rev (v :: aux)) l == L.append (L.rev aux) (v :: l)) | let list_append_rev_cons
(#t: Type)
(v: t)
(aux l: list t)
: Lemma (L.append (L.rev (v ::aux)) l == L.append (L.rev aux) (v :: l))
= L.rev_rev' (v :: aux);
L.rev_rev' aux;
L.append_assoc (L.rev aux) [v] l | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 42,
"start_col": 0,
"start_line": 35
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 | v: t -> aux: Prims.list t -> l: Prims.list t
-> FStar.Pervasives.Lemma
(ensures FStar.List.Tot.Base.rev (v :: aux) @ l == FStar.List.Tot.Base.rev aux @ v :: l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.List.Tot.Properties.append_assoc",
"FStar.List.Tot.Base.rev",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"FStar.List.Tot.Properties.rev_rev'",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let list_append_rev_cons (#t: Type) (v: t) (aux l: list t)
: Lemma (L.append (L.rev (v :: aux)) l == L.append (L.rev aux) (v :: l)) =
| L.rev_rev' (v :: aux);
L.rev_rev' aux;
L.append_assoc (L.rev aux) [v] l | false |
LowParse.SLow.List.fst | LowParse.SLow.List.parse_list_tailrec_measure | val parse_list_tailrec_measure (#t: Type) (x: option (bytes32 * list t)) : GTot nat | val parse_list_tailrec_measure (#t: Type) (x: option (bytes32 * list t)) : GTot nat | let parse_list_tailrec_measure
(#t: Type)
(x: option (bytes32 * list t))
: GTot nat
= match x with
| None -> 0
| Some (input', _) -> B32.length input' | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 144,
"start_col": 0,
"start_line": 138
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.Pervasives.Native.option (LowParse.SLow.Base.bytes32 * Prims.list t)
-> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.SLow.Base.bytes32",
"Prims.list",
"FStar.Bytes.length",
"Prims.nat"
] | [] | false | false | false | false | false | let parse_list_tailrec_measure (#t: Type) (x: option (bytes32 * list t)) : GTot nat =
| match x with
| None -> 0
| Some (input', _) -> B32.length input' | false |
LowParse.SLow.List.fst | LowParse.SLow.List.parse_list_tailrec | val parse_list_tailrec
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
: Tot (res: option (list t) {res == parse_list_tailrec' p32 input []}) | val parse_list_tailrec
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
: Tot (res: option (list t) {res == parse_list_tailrec' p32 input []}) | let parse_list_tailrec
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
: Tot (res: option (list t) { res == parse_list_tailrec' p32 input [] } )
= let accu =
CL.total_while
(parse_list_tailrec_measure #t)
(parse_list_tailrec_inv p32 input)
(fun x -> parse... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 192,
"start_col": 0,
"start_line": 176
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 | p32: LowParse.SLow.Base.parser32 p -> input: LowParse.SLow.Base.bytes32
-> res:
FStar.Pervasives.Native.option (Prims.list t)
{res == LowParse.SLow.List.parse_list_tailrec' p32 input []} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.None",
"Prims.list",
"FStar.Pervasives.Native.Some",
"LowParse.SLow.List.list_rev",
"FStar.Pervasives.Native.option",
"Prims.eq2",
"LowParse.SLow.L... | [] | false | false | false | false | false | let parse_list_tailrec
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
: Tot (res: option (list t) {res == parse_list_tailrec' p32 input []}) =
| let accu =
CL.total_while (parse_list_tailrec_measure #t)
(parse_list_tailrec_inv p32 input)
(fun x -> parse_list_tailrec_body p32 input x)
(Some (input, []))
in
match accu with
| None -> None
| Some (_, accu') -> Some (list_rev accu') | false |
LowParse.SLow.List.fst | LowParse.SLow.List.partial_serialize32_list'_init | val partial_serialize32_list'_init
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize (serialize_list p s) input) < 4294967296)
) (en... | val partial_serialize32_list'_init
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize (serialize_list p s) input) < 4294967296)
) (en... | let partial_serialize32_list'_init
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize (serialize_list p s) input) < 4294967296
))
(ensures (
partial_serialize32_l... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 124,
"end_line": 342,
"start_col": 0,
"start_line": 324
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: LowParse.Spec.Base.parser k t ->
s: LowParse.Spec.Base.serializer p ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
input: Prims.list t
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.List.serialize_list_precond k /\
FStar.Seq.Base.length (LowParse.Spec.Base.serialize ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"Prims.list",
"Prims._assert",
"LowParse.SLow.Base.serializer32_correct",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec... | [] | true | false | true | false | false | let partial_serialize32_list'_init
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize (serialize_list p s) input) < 4294967296)
) (en... | assert (Seq.equal (B32.reveal B32.empty_bytes) Seq.empty);
Seq.append_empty_l (B32.reveal (partial_serialize32_list' p s s32 input));
assert (B32.reveal (partial_serialize32_list' p s s32 input) ==
B32.reveal (partial_serialize32_list_tailrec' p s s32 B32.empty_bytes input));
assert (serializer32_correct (serialize... | false |
LowParse.SLow.List.fst | LowParse.SLow.List.parse_list_tailrec' | val parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: GTot (option (list t)) (decreases (B32.length b)) | val parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: GTot (option (list t)) (decreases (B32.length b)) | let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: GTot (option (list t))
(decreases (B32.length b))
= parse_list_eq p (B32.reveal b);
if B32.len b = 0ul
then
Some (L.rev aux)
else
match p32 b with
| None -> None
... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 63,
"end_line": 33,
"start_col": 0,
"start_line": 13
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 | p32: LowParse.SLow.Base.parser32 p -> b: LowParse.SLow.Base.bytes32 -> aux: Prims.list t
-> Prims.GTot (FStar.Pervasives.Native.option (Prims.list t)) | Prims.GTot | [
"sometrivial",
""
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"Prims.list",
"Prims.op_Equality",
"FStar.UInt32.t",
"FStar.Bytes.len",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Native.Some",
"FStar.List.Tot.Base.rev",
"Prims.bool... | [
"recursion"
] | false | false | false | false | false | let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: GTot (option (list t)) (decreases (B32.length b)) =
| parse_list_eq p (B32.reveal b);
if B32.len b = 0ul
then Some (L.rev aux)
else
match p32 b with
| None -> None
| Some (v, n) ->
if n = 0ul then None else parse_list_tailrec' p32 (B32.slice b n (B32.len b)) (v :: aux) | false |
LowParse.SLow.List.fst | LowParse.SLow.List.parse32_list | val parse32_list (#k: parser_kind) (#t: Type) (#p: parser k t) (p32: parser32 p)
: Tot (parser32 (parse_list p)) | val parse32_list (#k: parser_kind) (#t: Type) (#p: parser k t) (p32: parser32 p)
: Tot (parser32 (parse_list p)) | let parse32_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
: Tot (parser32 (parse_list p))
= fun (input: bytes32) -> ((
parse_list_tailrec'_correct p32 input;
parser_kind_prop_equiv parse_list_kind (parse_list p);
match parse_list_tailrec p32 input with
| None -> None
|... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 85,
"end_line": 208,
"start_col": 0,
"start_line": 195
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 | p32: LowParse.SLow.Base.parser32 p -> LowParse.SLow.Base.parser32 (LowParse.Spec.List.parse_list p) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.List.parse_list_tailrec",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Some",
"... | [] | false | false | false | false | false | let parse32_list (#k: parser_kind) (#t: Type) (#p: parser k t) (p32: parser32 p)
: Tot (parser32 (parse_list p)) =
| fun (input: bytes32) ->
((parse_list_tailrec'_correct p32 input;
parser_kind_prop_equiv parse_list_kind (parse_list p);
match parse_list_tailrec p32 input with
| None -> None
| Some res -> Some (res, B32.len input))
<:
(res: option (list t * U32.t) {parser32_correct (parse_list p) inpu... | false |
LowParse.SLow.List.fst | LowParse.SLow.List.partial_serialize32_list'_inv | val partial_serialize32_list'_inv
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(continue: bool)
(x: (bytes32 * list t))
: GTot Type0 | val partial_serialize32_list'_inv
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(continue: bool)
(x: (bytes32 * list t))
: GTot Type0 | let partial_serialize32_list'_inv
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(continue: bool)
(x: bytes32 * list t)
: GTot Type0
= serialize_list_precond k /\
Seq.length (serialize (serialize_list p s) input) < 4294967296 /\ (
let (... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 290,
"start_col": 0,
"start_line": 271
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: LowParse.Spec.Base.parser k t ->
s: LowParse.Spec.Base.serializer p ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
input: Prims.list t ->
continue: Prims.bool ->
x: (LowParse.SLow.Base.bytes32 * Prims.list t)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"Prims.list",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"LowParse.SLow.Base.bytes32",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_pr... | [] | false | false | false | false | true | let partial_serialize32_list'_inv
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(continue: bool)
(x: bytes32 * list t)
: GTot Type0 =
| serialize_list_precond k /\ Seq.length (serialize (serialize_list p s) input) < 4294967296 /\
(let accu, input' = x in
B32.length accu + Seq.length (serialize (serialize_list p s) input') < 4294967296 /\
serializer32_correct (serialize_list p s)
input
(partial_serialize32_list_tailrec' p s s32 accu input') ... | false |
LowParse.SLow.List.fst | LowParse.SLow.List.parse_list_tailrec_body | val parse_list_tailrec_body
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(x: option (bytes32 * list t))
: Pure (bool * option (bytes32 * list t))
(requires (parse_list_tailrec_inv p32 input true x))
(ensures
(fun (continue, ... | val parse_list_tailrec_body
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(x: option (bytes32 * list t))
: Pure (bool * option (bytes32 * list t))
(requires (parse_list_tailrec_inv p32 input true x))
(ensures
(fun (continue, ... | let parse_list_tailrec_body
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
: (x: option (bytes32 * list t)) ->
Pure (bool * option (bytes32 * list t))
(requires (parse_list_tailrec_inv p32 input true x))
(ensures (fun (continue, y) ->
parse_list_tailrec_inv p32 inpu... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 173,
"start_col": 0,
"start_line": 147
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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 |
p32: LowParse.SLow.Base.parser32 p ->
input: LowParse.SLow.Base.bytes32 ->
x: FStar.Pervasives.Native.option (LowParse.SLow.Base.bytes32 * Prims.list t)
-> Prims.Pure
(Prims.bool * FStar.Pervasives.Native.option (LowParse.SLow.Base.bytes32 * Prims.list t)) | Prims.Pure | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"Prims.op_Equality",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Nativ... | [] | false | false | false | false | false | let parse_list_tailrec_body
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(input: bytes32)
(x: option (bytes32 * list t))
: Pure (bool * option (bytes32 * list t))
(requires (parse_list_tailrec_inv p32 input true x))
(ensures
... | fun (x: option (bytes32 * list t)) ->
let Some (input', accu') = x in
let len = B32.len input' in
if len = 0ul
then (false, x)
else
match p32 input' with
| Some (v, consumed) ->
if consumed = 0ul
then (false, None)
else
let input'' = B32.slice input' consumed len in
(... | false |
LowParse.SLow.List.fst | LowParse.SLow.List.list_rev | val list_rev (#t: Type) (l: list t) : Tot (l': list t {l' == L.rev l}) | val list_rev (#t: Type) (l: list t) : Tot (l': list t {l' == L.rev l}) | let list_rev
(#t: Type)
(l: list t)
: Tot (l' : list t { l' == L.rev l } )
= match l with
| [] -> []
| _ ->
let (_, l') =
CL.total_while
(fun (rem, _) -> L.length rem)
(list_rev_inv l)
(fun (rem, acc) ->
match rem with
| [] -> (false, (rem, acc))
|... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 120,
"start_col": 0,
"start_line": 102
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": 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.list t -> l': Prims.list t {l' == FStar.List.Tot.Base.rev l} | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.Nil",
"Prims.eq2",
"FStar.List.Tot.Base.rev",
"FStar.Pervasives.Native.tuple2",
"C.Loops.total_while",
"FStar.List.Tot.Base.length",
"Prims.nat",
"LowParse.SLow.List.list_rev_inv",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"Prims.Cons"
] | [] | false | false | false | false | false | let list_rev (#t: Type) (l: list t) : Tot (l': list t {l' == L.rev l}) =
| match l with
| [] -> []
| _ ->
let _, l' =
CL.total_while (fun (rem, _) -> L.length rem)
(list_rev_inv l)
(fun (rem, acc) ->
match rem with
| [] -> (false, (rem, acc))
| a :: q -> (true, (q, a :: acc)))
(l, [])
in
l' | false |
LowParse.SLow.List.fst | LowParse.SLow.List.partial_serialize32_list'_body | val partial_serialize32_list'_body
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(x: (bytes32 * list t))
: Pure (bool * (bytes32 * list t))
(requires (partial_serialize32_list'_inv p s s32 input true x))
... | val partial_serialize32_list'_body
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(x: (bytes32 * list t))
: Pure (bool * (bytes32 * list t))
(requires (partial_serialize32_list'_inv p s s32 input true x))
... | let partial_serialize32_list'_body
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: (x: (bytes32 * list t)) ->
Pure (bool * (bytes32 * list t))
(requires (partial_serialize32_list'_inv p s s32 input true x))
(ensures (fun (continue, y) ->
... | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 22,
"end_line": 322,
"start_col": 0,
"start_line": 299
} | module LowParse.SLow.List
include LowParse.Spec.List
include LowParse.SLow.Combinators
module B32 = FStar.Bytes
module U32 = FStar.UInt32
module CL = C.Loops
#set-options "--z3rlimit 16 --max_fuel 8 --max_ifuel 8"
module L = FStar.List.Tot
let rec parse_list_tailrec'
(#k: parser_kind)
(#t: Type)
(#p: parser k... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.List.fsti.checked",
"LowParse.SLow.Combinators.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "C.Loops",
"short_module": "CL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Byte... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: LowParse.Spec.Base.parser k t ->
s: LowParse.Spec.Base.serializer p ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
input: Prims.list t ->
x: (LowParse.SLow.Base.bytes32 * Prims.list t)
-> Prims.Pure (Prims.bool * (LowParse.SLow.Base.bytes32 * Prims.list t)) | Prims.Pure | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.SLow.Base.bytes32",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"FStar.Bytes.bytes",
"FStar.B... | [] | false | false | false | false | false | let partial_serialize32_list'_body
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
(x: (bytes32 * list t))
: Pure (bool * (bytes32 * list t))
(requires (partial_serialize32_list'_inv p s s32 input tr... | fun (x: bytes32 * list t) ->
let accu, input' = x in
match input' with
| [] -> (false, x)
| a :: q ->
[@@ inline_let ]let _ = serialize_list_cons p s a q in
let sa = s32 a in
let accu' = B32.append accu sa in
(true, (accu', q)) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.