effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | [
{
"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,
... | false | let widefelem = lbuffer uint64 (size 8) | let widefelem = | false | null | false | lbuffer uint64 (size 8) | {
"checked_file": "Hacl.Impl.P256.Bignum.fsti.checked",
"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",
... | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size"
] | [] | 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... | false | true | Hacl.Impl.P256.Bignum.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val widefelem : Type0 | [] | Hacl.Impl.P256.Bignum.widefelem | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 39,
"end_line": 20,
"start_col": 16,
"start_line": 20
} | |
Prims.GTot | val as_nat (h: mem) (e: felem) : GTot nat | [
{
"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,
... | false | let as_nat (h:mem) (e:felem) : GTot nat =
BD.bn_v (as_seq h e) | val as_nat (h: mem) (e: felem) : GTot nat
let as_nat (h: mem) (e: felem) : GTot nat = | false | null | false | BD.bn_v (as_seq h e) | {
"checked_file": "Hacl.Impl.P256.Bignum.fsti.checked",
"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",
... | [
"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"
] | [] | 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... | false | false | Hacl.Impl.P256.Bignum.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val as_nat (h: mem) (e: felem) : GTot nat | [] | Hacl.Impl.P256.Bignum.as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.P256.Bignum.felem -> Prims.GTot Prims.nat | {
"end_col": 22,
"end_line": 24,
"start_col": 2,
"start_line": 24
} |
Prims.GTot | val wide_as_nat (h: mem) (e: widefelem) : GTot nat | [
{
"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,
... | false | let wide_as_nat (h:mem) (e:widefelem) : GTot nat =
BD.bn_v (as_seq h e) | val wide_as_nat (h: mem) (e: widefelem) : GTot nat
let wide_as_nat (h: mem) (e: widefelem) : GTot nat = | false | null | false | BD.bn_v (as_seq h e) | {
"checked_file": "Hacl.Impl.P256.Bignum.fsti.checked",
"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",
... | [
"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"
] | [] | 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... | false | false | Hacl.Impl.P256.Bignum.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val wide_as_nat (h: mem) (e: widefelem) : GTot nat | [] | Hacl.Impl.P256.Bignum.wide_as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Bignum.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.P256.Bignum.widefelem -> Prims.GTot Prims.nat | {
"end_col": 22,
"end_line": 28,
"start_col": 2,
"start_line": 28
} |
Prims.Tot | val equal (#a:Type) (m1 m2:map16 a) : Type0 | [
{
"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... | false | let equal #a m1 m2 = m1 == m2 | val equal (#a:Type) (m1 m2:map16 a) : Type0
let equal #a m1 m2 = | false | null | false | m1 == m2 | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"total"
] | [
"Vale.Lib.Map16.map16",
"Prims.eq2"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val equal (#a:Type) (m1 m2:map16 a) : Type0 | [] | Vale.Lib.Map16.equal | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m1: Vale.Lib.Map16.map16 a -> m2: Vale.Lib.Map16.map16 a -> Type0 | {
"end_col": 29,
"end_line": 67,
"start_col": 21,
"start_line": 67
} |
FStar.Pervasives.Lemma | val lemma_eta (#a:Type) (m:map16 a) : Lemma
(ensures eta m == m)
[SMTPat (eta m)] | [
{
"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... | false | let lemma_eta (#a:Type) (m:map16 a) =
assert_norm (eta m == eta16 m);
lemma_eta16 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) = | false | null | true | assert_norm (eta m == eta16 m);
lemma_eta16 m | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"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"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_eta (#a:Type) (m:map16 a) : Lemma
(ensures eta m == m)
[SMTPat (eta m)] | [] | Vale.Lib.Map16.lemma_eta | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.Lib.Map16.map16 a
-> FStar.Pervasives.Lemma (ensures Vale.Lib.Map16.eta m == m) [SMTPat (Vale.Lib.Map16.eta m)] | {
"end_col": 15,
"end_line": 65,
"start_col": 2,
"start_line": 64
} |
FStar.Pervasives.Lemma | 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) | [
{
"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... | 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 | 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) = | false | null | true | 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 | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"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"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_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) | [] | Vale.Lib.Map16.lemma_equal | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 21,
"end_line": 40,
"start_col": 2,
"start_line": 38
} |
FStar.Pervasives.Lemma | 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)] | [
{
"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... | false | let lemma_equal_intro #a m1 m2 =
lemma_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 = | false | null | true | lemma_equal m1 m2;
() | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"lemma"
] | [
"Vale.Lib.Map16.map16",
"Prims.unit",
"Vale.Lib.Map16.lemma_equal"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_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)] | [] | Vale.Lib.Map16.lemma_equal_intro | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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)
... | {
"end_col": 4,
"end_line": 71,
"start_col": 2,
"start_line": 70
} |
Prims.Pure | 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) | [
{
"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... | false | let init a f =
init_rec a f 16 | 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 = | false | null | false | init_rec a f 16 | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Lib.Map16.init_rec",
"Vale.Lib.Map16.map16"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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) | [] | Vale.Lib.Map16.init | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Type -> f: (i: Prims.nat{i < 16} -> a) -> Prims.Pure (Vale.Lib.Map16.map16 a) | {
"end_col": 17,
"end_line": 88,
"start_col": 2,
"start_line": 88
} |
FStar.Pervasives.Lemma | 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)] | [
{
"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... | 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 | 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) = | false | null | true | assert_norm (sel (upd m n v) n == sel16 (upd16 m n v) n);
lemma_self16 m n v | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"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"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_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)] | [] | Vale.Lib.Map16.lemma_self | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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)] | {
"end_col": 20,
"end_line": 30,
"start_col": 2,
"start_line": 29
} |
FStar.Pervasives.Lemma | 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)] | [
{
"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... | 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 | 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) = | false | null | true | 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 | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"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"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_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)] | [] | Vale.Lib.Map16.lemma_other | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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... | {
"end_col": 25,
"end_line": 35,
"start_col": 2,
"start_line": 33
} |
Prims.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) | [
{
"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... | false | let init_ghost a f =
init_ghost_rec a f 16 | 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 = | false | null | false | init_ghost_rec a f 16 | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Lib.Map16.init_ghost_rec",
"Vale.Lib.Map16.map16"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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) | [] | Vale.Lib.Map16.init_ghost | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Type -> f: (i: Prims.nat{i < 16} -> Prims.GTot a) -> Prims.Ghost (Vale.Lib.Map16.map16 a) | {
"end_col": 23,
"end_line": 102,
"start_col": 2,
"start_line": 102
} |
FStar.Pervasives.Lemma | val lemma_eta16 (#a:Type) (m:map16 a) : Lemma
(ensures eta16 m == m) | [
{
"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... | 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);
... | val lemma_eta16 (#a:Type) (m:map16 a) : Lemma
(ensures eta16 m == m)
let lemma_eta16 (#a: Type) (m: map16 a) = | false | null | true | 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)... | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"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"
] | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_eta16 (#a:Type) (m:map16 a) : Lemma
(ensures eta16 m == m) | [] | Vale.Lib.Map16.lemma_eta16 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.Lib.Map16.map16 a -> FStar.Pervasives.Lemma (ensures Vale.Lib.Map16.eta16 m == m) | {
"end_col": 25,
"end_line": 61,
"start_col": 39,
"start_line": 42
} |
FStar.Pervasives.Lemma | 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) | [
{
"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... | 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);
... | 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) = | false | null | true | 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... | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [
"lemma"
] | [
"Vale.Lib.Map16.map16",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Vale.Lib.Map16.sel16"
] | [] | 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" | false | false | Vale.Lib.Map16.fst | {
"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... | null | 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) | [] | Vale.Lib.Map16.lemma_equal16 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 4,
"end_line": 25,
"start_col": 2,
"start_line": 9
} |
Prims.Pure | 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) | [
{
"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... | 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 ... | 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... | false | null | false | 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)) | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [] | [
"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.... | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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) | [
"recursion"
] | Vale.Lib.Map16.init_rec | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Type -> f: (i: Prims.nat{i < 16} -> a) -> n: Prims.nat -> Prims.Pure (Vale.Lib.Map16.map16 a) | {
"end_col": 50,
"end_line": 85,
"start_col": 2,
"start_line": 80
} |
Prims.Ghost | 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) | [
{
"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... | 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_re... | 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 <= ... | false | null | false | 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)) | {
"checked_file": "Vale.Lib.Map16.fst.checked",
"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"
} | [] | [
"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",
"... | [] | 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... | false | false | Vale.Lib.Map16.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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) | [
"recursion"
] | Vale.Lib.Map16.init_ghost_rec | {
"file_name": "vale/code/lib/collections/Vale.Lib.Map16.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Type -> f: (i: Prims.nat{i < 16} -> Prims.GTot a) -> n: Prims.nat
-> Prims.Ghost (Vale.Lib.Map16.map16 a) | {
"end_col": 56,
"end_line": 99,
"start_col": 2,
"start_line": 94
} |
Prims.Tot | val primops : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let primops = Primops | val primops : norm_step
let primops = | false | null | false | Primops | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Primops"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val primops : norm_step | [] | FStar.Pervasives.primops | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 21,
"end_line": 79,
"start_col": 14,
"start_line": 79
} |
Prims.Tot | val ambient (#a: Type) (x: a) : Type0 | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ambient #_ _ = True | val ambient (#a: Type) (x: a) : Type0
let ambient #_ _ = | false | null | false | True | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.l_True"
] | [] | (*
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... | false | false | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ambient (#a: Type) (x: a) : Type0 | [] | FStar.Pervasives.ambient | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> Type0 | {
"end_col": 23,
"end_line": 37,
"start_col": 19,
"start_line": 37
} |
Prims.Tot | val iota : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let iota = Iota | val iota : norm_step
let iota = | false | null | false | Iota | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Iota"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val iota : norm_step | [] | FStar.Pervasives.iota | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 15,
"end_line": 94,
"start_col": 11,
"start_line": 94
} |
Prims.Tot | val norm (s: list norm_step) (#a: Type) (x: a) : Tot a | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let norm _ #_ x = x | val norm (s: list norm_step) (#a: Type) (x: a) : Tot a
let norm _ #_ x = | false | null | false | x | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.list",
"FStar.Pervasives.norm_step"
] | [] | (*
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... | false | false | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val norm (s: list norm_step) (#a: Type) (x: a) : Tot a | [] | FStar.Pervasives.norm | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: Prims.list FStar.Pervasives.norm_step -> x: a -> a | {
"end_col": 19,
"end_line": 123,
"start_col": 18,
"start_line": 123
} |
Prims.Tot | val zeta_full : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let zeta_full = ZetaFull | val zeta_full : norm_step
let zeta_full = | false | null | false | ZetaFull | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.ZetaFull"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val zeta_full : norm_step | [] | FStar.Pervasives.zeta_full | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 24,
"end_line": 91,
"start_col": 16,
"start_line": 91
} |
Prims.Tot | val delta_fully (s: list string) : Tot norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let delta_fully s = UnfoldFully s | val delta_fully (s: list string) : Tot norm_step
let delta_fully s = | false | null | false | UnfoldFully s | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldFully",
"FStar.Pervasives.norm_step"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val delta_fully (s: list string) : Tot norm_step | [] | FStar.Pervasives.delta_fully | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: Prims.list Prims.string -> FStar.Pervasives.norm_step | {
"end_col": 33,
"end_line": 106,
"start_col": 20,
"start_line": 106
} |
Prims.Tot | val norm_debug : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let norm_debug = NormDebug | val norm_debug : norm_step
let norm_debug = | false | null | false | NormDebug | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.NormDebug"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val norm_debug : norm_step | [] | FStar.Pervasives.norm_debug | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 26,
"end_line": 85,
"start_col": 17,
"start_line": 85
} |
Prims.Tot | val delta_namespace (s: list string) : Tot norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let delta_namespace s = UnfoldNamespace s | val delta_namespace (s: list string) : Tot norm_step
let delta_namespace s = | false | null | false | UnfoldNamespace s | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldNamespace",
"FStar.Pervasives.norm_step"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val delta_namespace (s: list string) : Tot norm_step | [] | FStar.Pervasives.delta_namespace | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: Prims.list Prims.string -> FStar.Pervasives.norm_step | {
"end_col": 41,
"end_line": 115,
"start_col": 24,
"start_line": 115
} |
Prims.Tot | val nbe : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let nbe = NBE | val nbe : norm_step
let nbe = | false | null | false | NBE | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.NBE"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nbe : norm_step | [] | FStar.Pervasives.nbe | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 13,
"end_line": 97,
"start_col": 10,
"start_line": 97
} |
Prims.Tot | val unmeta : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let unmeta = Unmeta | val unmeta : norm_step
let unmeta = | false | null | false | Unmeta | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Unmeta"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val unmeta : norm_step | [] | FStar.Pervasives.unmeta | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 19,
"end_line": 118,
"start_col": 13,
"start_line": 118
} |
Prims.Tot | val delta : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let delta = Delta | val delta : norm_step
let delta = | false | null | false | Delta | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Delta"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val delta : norm_step | [] | FStar.Pervasives.delta | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 17,
"end_line": 82,
"start_col": 12,
"start_line": 82
} |
Prims.Tot | val unascribe : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let unascribe = Unascribe | val unascribe : norm_step
let unascribe = | false | null | false | Unascribe | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Unascribe"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val unascribe : norm_step | [] | FStar.Pervasives.unascribe | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 25,
"end_line": 121,
"start_col": 16,
"start_line": 121
} |
Prims.Tot | val spinoff (p: Type0) : Type0 | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let spinoff p = p | val spinoff (p: Type0) : Type0
let spinoff p = | false | null | false | p | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val spinoff (p: Type0) : Type0 | [] | FStar.Pervasives.spinoff | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: Type0 -> Type0 | {
"end_col": 17,
"end_line": 29,
"start_col": 16,
"start_line": 29
} |
Prims.Tot | val zeta : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let zeta = Zeta | val zeta : norm_step
let zeta = | false | null | false | Zeta | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Zeta"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val zeta : norm_step | [] | FStar.Pervasives.zeta | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 15,
"end_line": 88,
"start_col": 11,
"start_line": 88
} |
Prims.Tot | val delta_attr (s: list string) : Tot norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let delta_attr s = UnfoldAttr s | val delta_attr (s: list string) : Tot norm_step
let delta_attr s = | false | null | false | UnfoldAttr s | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldAttr",
"FStar.Pervasives.norm_step"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val delta_attr (s: list string) : Tot norm_step | [] | FStar.Pervasives.delta_attr | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: Prims.list Prims.string -> FStar.Pervasives.norm_step | {
"end_col": 31,
"end_line": 109,
"start_col": 19,
"start_line": 109
} |
Prims.Tot | val singleton (#a: Type) (x: a) : Tot (y: a{y == x}) | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let singleton #_ x = x | val singleton (#a: Type) (x: a) : Tot (y: a{y == x})
let singleton #_ x = | false | null | false | x | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.eq2"
] | [] | (*
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... | false | false | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val singleton (#a: Type) (x: a) : Tot (y: a{y == x}) | [] | FStar.Pervasives.singleton | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> y: a{y == x} | {
"end_col": 22,
"end_line": 197,
"start_col": 21,
"start_line": 197
} |
Prims.Tot | val normalize_term (#a: Type) (x: a) : Tot a | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let normalize_term #_ x = x | val normalize_term (#a: Type) (x: a) : Tot a
let normalize_term #_ x = | false | null | false | x | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [] | [] | (*
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... | false | false | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val normalize_term (#a: Type) (x: a) : Tot a | [] | FStar.Pervasives.normalize_term | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> a | {
"end_col": 27,
"end_line": 41,
"start_col": 26,
"start_line": 41
} |
Prims.Tot | val normalize (a: Type0) : Type0 | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let normalize a = a | val normalize (a: Type0) : Type0
let normalize a = | false | null | false | a | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val normalize (a: Type0) : Type0 | [] | FStar.Pervasives.normalize | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type0 -> Type0 | {
"end_col": 19,
"end_line": 43,
"start_col": 18,
"start_line": 43
} |
Prims.Tot | val simplify : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let simplify = Simpl | val simplify : norm_step
let simplify = | false | null | false | Simpl | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Simpl"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val simplify : norm_step | [] | FStar.Pervasives.simplify | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 20,
"end_line": 70,
"start_col": 15,
"start_line": 70
} |
Prims.Tot | val delta_only (s: list string) : Tot norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let delta_only s = UnfoldOnly s | val delta_only (s: list string) : Tot norm_step
let delta_only s = | false | null | false | UnfoldOnly s | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldOnly",
"FStar.Pervasives.norm_step"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val delta_only (s: list string) : Tot norm_step | [] | FStar.Pervasives.delta_only | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: Prims.list Prims.string -> FStar.Pervasives.norm_step | {
"end_col": 31,
"end_line": 103,
"start_col": 19,
"start_line": 103
} |
Prims.Tot | val hnf : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let hnf = HNF | val hnf : norm_step
let hnf = | false | null | false | HNF | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.HNF"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val hnf : norm_step | [] | FStar.Pervasives.hnf | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 13,
"end_line": 76,
"start_col": 10,
"start_line": 76
} |
Prims.Tot | val delta_qualifier (s: list string) : Tot norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let delta_qualifier s = UnfoldAttr s | val delta_qualifier (s: list string) : Tot norm_step
let delta_qualifier s = | false | null | false | UnfoldAttr s | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.string",
"FStar.Pervasives.UnfoldAttr",
"FStar.Pervasives.norm_step"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val delta_qualifier (s: list string) : Tot norm_step | [] | FStar.Pervasives.delta_qualifier | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: Prims.list Prims.string -> FStar.Pervasives.norm_step | {
"end_col": 36,
"end_line": 112,
"start_col": 24,
"start_line": 112
} |
Prims.Tot | val reify_ : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let reify_ = Reify | val reify_ : norm_step
let reify_ = | false | null | false | Reify | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Reify"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val reify_ : norm_step | [] | FStar.Pervasives.reify_ | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 18,
"end_line": 100,
"start_col": 13,
"start_line": 100
} |
Prims.Tot | val weak : norm_step | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let weak = Weak | val weak : norm_step
let weak = | false | null | false | Weak | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"FStar.Pervasives.Weak"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val weak : norm_step | [] | FStar.Pervasives.weak | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Pervasives.norm_step | {
"end_col": 15,
"end_line": 73,
"start_col": 11,
"start_line": 73
} |
Prims.Tot | val inversion (a: Type) : Type0 | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let inversion _ = True | val inversion (a: Type) : Type0
let inversion _ = | false | null | false | True | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.l_True"
] | [] | (*
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... | false | true | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val inversion (a: Type) : Type0 | [] | FStar.Pervasives.inversion | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type -> Type0 | {
"end_col": 22,
"end_line": 133,
"start_col": 18,
"start_line": 133
} |
Prims.Tot | val false_elim (#a: Type) (u: unit{False}) : Tot a | [
{
"abbrev": false,
"full_module": "FStar.Pervasives.Native",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec false_elim #_ _ = false_elim () | val false_elim (#a: Type) (u: unit{False}) : Tot a
let rec false_elim #_ _ = | false | null | false | false_elim () | {
"checked_file": "FStar.Pervasives.fst.checked",
"dependencies": [
"prims.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Pervasives.fst"
} | [
"total"
] | [
"Prims.unit",
"Prims.l_False",
"FStar.Pervasives.false_elim"
] | [] | (*
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... | false | false | FStar.Pervasives.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val false_elim (#a: Type) (u: unit{False}) : Tot a | [
"recursion"
] | FStar.Pervasives.false_elim | {
"file_name": "ulib/FStar.Pervasives.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | u361: u362: Prims.unit{Prims.l_False} -> a | {
"end_col": 39,
"end_line": 139,
"start_col": 26,
"start_line": 139
} |
Prims.Tot | val increasing:preorder nat | [
{
"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... | false | let increasing : preorder nat = fun (x y:nat) -> b2t (x <= y) | val increasing:preorder nat
let increasing:preorder nat = | false | null | false | fun (x: nat) (y: nat) -> b2t (x <= y) | {
"checked_file": "Steel.MonotonicCounter.fst.checked",
"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": "... | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.logical"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.MonotonicCounter.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val increasing:preorder nat | [] | Steel.MonotonicCounter.increasing | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | FStar.Preorder.preorder Prims.nat | {
"end_col": 61,
"end_line": 42,
"start_col": 32,
"start_line": 42
} |
Prims.Tot | val pre_pcm:pcm' nat | [
{
"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... | false | let pre_pcm : pcm' nat = {
composable=(fun x y -> True);
op=(fun (x y:nat) -> Math.Lib.max x y);
one=0
} | val pre_pcm:pcm' nat
let pre_pcm:pcm' nat = | false | null | false | { composable = (fun x y -> True); op = (fun (x: nat) (y: nat) -> Math.Lib.max x y); one = 0 } | {
"checked_file": "Steel.MonotonicCounter.fst.checked",
"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": "... | [
"total"
] | [
"FStar.PCM.Mkpcm'",
"Prims.nat",
"Prims.l_True",
"Prims.prop",
"FStar.Math.Lib.max"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.MonotonicCounter.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pre_pcm:pcm' nat | [] | Steel.MonotonicCounter.pre_pcm | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | FStar.PCM.pcm' Prims.nat | {
"end_col": 7,
"end_line": 30,
"start_col": 2,
"start_line": 28
} |
FStar.Pervasives.Lemma | val test (x z: nat) (f: (nat -> prop){stable f increasing})
: Lemma (requires (compatible mctr_pcm x z /\ f x)) (ensures f z) | [
{
"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... | 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) | 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) = | false | null | true | assert (increasing x z) | {
"checked_file": "Steel.MonotonicCounter.fst.checked",
"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": "... | [
"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"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.MonotonicCounter.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val test (x z: nat) (f: (nat -> prop){stable f increasing})
: Lemma (requires (compatible mctr_pcm x z /\ f x)) (ensures f z) | [] | Steel.MonotonicCounter.test | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
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) | {
"end_col": 27,
"end_line": 62,
"start_col": 4,
"start_line": 62
} |
Prims.Tot | val mctr_induces_increases:squash (induces_preorder mctr_pcm increasing) | [
{
"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... | 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
() | val mctr_induces_increases:squash (induces_preorder mctr_pcm increasing)
let mctr_induces_increases:squash (induces_preorder mctr_pcm increasing) = | false | null | true | 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
() | {
"checked_file": "Steel.MonotonicCounter.fst.checked",
"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": "... | [
"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... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.MonotonicCounter.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mctr_induces_increases:squash (induces_preorder mctr_pcm increasing) | [] | Steel.MonotonicCounter.mctr_induces_increases | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | Prims.squash (Steel.Preorder.induces_preorder Steel.MonotonicCounter.mctr_pcm
Steel.MonotonicCounter.increasing) | {
"end_col": 6,
"end_line": 54,
"start_col": 3,
"start_line": 48
} |
Prims.Tot | val mctr_pcm:pcm nat | [
{
"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... | false | let mctr_pcm : pcm nat = {
p=pre_pcm;
comm=(fun _ _ -> ());
assoc=(fun _ _ _ -> ());
assoc_r=(fun _ _ _ -> ());
is_unit=(fun _ -> ());
refine=(fun _ -> True);
} | val mctr_pcm:pcm nat
let mctr_pcm:pcm nat = | false | null | false | {
p = pre_pcm;
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | {
"checked_file": "Steel.MonotonicCounter.fst.checked",
"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": "... | [
"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"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.MonotonicCounter.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mctr_pcm:pcm nat | [] | Steel.MonotonicCounter.mctr_pcm | {
"file_name": "lib/steel/Steel.MonotonicCounter.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | FStar.PCM.pcm Prims.nat | {
"end_col": 25,
"end_line": 38,
"start_col": 2,
"start_line": 33
} |
Prims.GTot | val list_rev_inv (#t: Type) (l: list t) (b: bool) (x: (list t * list t)) : GTot Type0 | [
{
"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... | false | 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 == []) | 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 = | false | null | false | let rem, acc = x in
L.rev l == L.rev_acc rem acc /\ (b == false ==> rem == []) | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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"
] | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val list_rev_inv (#t: Type) (l: list t) (b: bool) (x: (list t * list t)) : GTot Type0 | [] | LowParse.SLow.List.list_rev_inv | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list t -> b: Prims.bool -> x: (Prims.list t * Prims.list t) -> Prims.GTot Type0 | {
"end_col": 28,
"end_line": 100,
"start_col": 1,
"start_line": 98
} |
Prims.GTot | val partial_serialize32_list'_measure (#t: Type) (x: (bytes32 * list t)) : GTot nat | [
{
"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... | false | let partial_serialize32_list'_measure
(#t: Type)
(x: bytes32 * list t)
: GTot nat
= L.length (snd x) | 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 = | false | null | false | L.length (snd x) | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"sometrivial"
] | [
"FStar.Pervasives.Native.tuple2",
"LowParse.SLow.Base.bytes32",
"Prims.list",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.snd",
"Prims.nat"
] | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val partial_serialize32_list'_measure (#t: Type) (x: (bytes32 * list t)) : GTot nat | [] | LowParse.SLow.List.partial_serialize32_list'_measure | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: (LowParse.SLow.Base.bytes32 * Prims.list t) -> Prims.GTot Prims.nat | {
"end_col": 18,
"end_line": 296,
"start_col": 2,
"start_line": 296
} |
Prims.GTot | val size32_list_measure (#t: Type) (accu: (U32.t * list t)) : GTot nat | [
{
"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... | false | let size32_list_measure
(#t: Type)
(accu: (U32.t * list t))
: GTot nat
= let (_, rem) = accu in
L.length rem | 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 = | false | null | false | let _, rem = accu in
L.length rem | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"sometrivial"
] | [
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"Prims.list",
"FStar.List.Tot.Base.length",
"Prims.nat"
] | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val size32_list_measure (#t: Type) (accu: (U32.t * list t)) : GTot nat | [] | LowParse.SLow.List.size32_list_measure | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | accu: (FStar.UInt32.t * Prims.list t) -> Prims.GTot Prims.nat | {
"end_col": 14,
"end_line": 394,
"start_col": 1,
"start_line": 393
} |
Prims.GTot | val parse_list_tailrec_measure (#t: Type) (x: option (bytes32 * list t)) : GTot nat | [
{
"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... | 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' | 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 = | false | null | false | match x with
| None -> 0
| Some (input', _) -> B32.length input' | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"sometrivial"
] | [
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.SLow.Base.bytes32",
"Prims.list",
"FStar.Bytes.length",
"Prims.nat"
] | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val parse_list_tailrec_measure (#t: Type) (x: option (bytes32 * list t)) : GTot nat | [] | LowParse.SLow.List.parse_list_tailrec_measure | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.Pervasives.Native.option (LowParse.SLow.Base.bytes32 * Prims.list t)
-> Prims.GTot Prims.nat | {
"end_col": 41,
"end_line": 144,
"start_col": 2,
"start_line": 142
} |
Prims.GTot | 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 | [
{
"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... | false | 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... | 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 ... | false | null | false | 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 []) | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | 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 | [] | LowParse.SLow.List.parse_list_tailrec_inv | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
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 | {
"end_col": 58,
"end_line": 136,
"start_col": 2,
"start_line": 131
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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... | 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 | 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)) = | false | null | true | L.rev_rev' (v :: aux);
L.rev_rev' aux;
L.append_assoc (L.rev aux) [v] l | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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"
] | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | 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)) | [] | LowParse.SLow.List.list_append_rev_cons | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | 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) | {
"end_col": 34,
"end_line": 42,
"start_col": 2,
"start_line": 40
} |
Prims.GTot | val size32_list_inv
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit{serialize_list_precond k})
(input: list t)
(continue: bool)
(accu: (U32.t * list t))
: GTot Type0 | [
{
"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... | false | let size32_list_inv
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit {
serialize_list_precond k
})
(input: list t)
(continue: bool)
(accu: (U32.t * list t))
: GTot Type0
= let (len, rem) = accu in
let sz = Seq.length (serialize (serialize_list p s) inpu... | val size32_list_inv
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit{serialize_list_precond k})
(input: list t)
(continue: bool)
(accu: (U32.t * list t))
: GTot Type0
let size32_list_inv
(#t: Type)
(#k: parser... | false | null | false | let len, rem = accu in
let sz = Seq.length (serialize (serialize_list p s) input) in
if continue
then U32.v len < U32.v u32_max /\ sz == U32.v len + Seq.length (serialize (serialize_list p s) rem)
else size32_postcond (serialize_list p s) input len | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"Prims.unit",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.list",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"FStar.UInt32.t",
"Prims.l_and",
... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val size32_list_inv
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit{serialize_list_precond k})
(input: list t)
(continue: bool)
(accu: (U32.t * list t))
: GTot Type0 | [] | LowParse.SLow.List.size32_list_inv | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s32: LowParse.SLow.Base.size32 s ->
u107: u111: Prims.unit{LowParse.Spec.List.serialize_list_precond k} ->
input: Prims.list t ->
continue: Prims.bool ->
accu: (FStar.UInt32.t * Prims.list t)
-> Prims.GTot Type0 | {
"end_col": 50,
"end_line": 387,
"start_col": 1,
"start_line": 380
} |
Prims.Tot | 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 []}) | [
{
"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... | 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... | 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)
... | false | null | false | 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') | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | 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 []}) | [] | LowParse.SLow.List.parse_list_tailrec | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | 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 []} | {
"end_col": 44,
"end_line": 192,
"start_col": 1,
"start_line": 183
} |
Prims.GTot | 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 | [
{
"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... | false | 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 (... | 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_ki... | false | null | false | 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') ... | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | 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 | [] | LowParse.SLow.List.partial_serialize32_list'_inv | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
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 | {
"end_col": 3,
"end_line": 290,
"start_col": 2,
"start_line": 281
} |
Prims.Tot | val list_rev (#t: Type) (l: list t) : Tot (l': list t {l' == L.rev l}) | [
{
"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... | 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))
|... | 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}) = | false | null | false | 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' | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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"
] | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val list_rev (#t: Type) (l: list t) : Tot (l': list t {l' == L.rev l}) | [] | LowParse.SLow.List.list_rev | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list t -> l': Prims.list t {l' == FStar.List.Tot.Base.rev l} | {
"end_col": 6,
"end_line": 120,
"start_col": 2,
"start_line": 106
} |
Prims.Tot | val parse32_list (#k: parser_kind) (#t: Type) (#p: parser k t) (p32: parser32 p)
: Tot (parser32 (parse_list p)) | [
{
"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... | 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
|... | 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)) = | false | null | false | 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... | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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",
"... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val parse32_list (#k: parser_kind) (#t: Type) (#p: parser k t) (p32: parser32 p)
: Tot (parser32 (parse_list p)) | [] | LowParse.SLow.List.parse32_list | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p32: LowParse.SLow.Base.parser32 p -> LowParse.SLow.Base.parser32 (LowParse.Spec.List.parse_list p) | {
"end_col": 85,
"end_line": 208,
"start_col": 2,
"start_line": 201
} |
FStar.Pervasives.Lemma | 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... | [
{
"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... | 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
))
(ensures (
partial_serialize32_l... | 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... | false | null | true | 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... | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | 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... | [] | LowParse.SLow.List.partial_serialize32_list'_init | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
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 ... | {
"end_col": 124,
"end_line": 342,
"start_col": 2,
"start_line": 339
} |
Prims.GTot | 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)) | [
{
"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... | 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
... | 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 ... | false | null | false | 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) | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"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... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | 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)) | [
"recursion"
] | LowParse.SLow.List.parse_list_tailrec' | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p32: LowParse.SLow.Base.parser32 p -> b: LowParse.SLow.Base.bytes32 -> aux: Prims.list t
-> Prims.GTot (FStar.Pervasives.Native.option (Prims.list t)) | {
"end_col": 63,
"end_line": 33,
"start_col": 2,
"start_line": 22
} |
Prims.Tot | val partial_serialize32_list
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(u: unit{serialize_list_precond k})
: Tot (partial_serializer32 (serialize_list p s)) | [
{
"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... | false | let partial_serialize32_list
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(u: unit {
serialize_list_precond k
})
: Tot (partial_serializer32 (serialize_list p s))
= fun (input: list t { Seq.length (serialize (serialize_list p s) input) < 4294967296 } ) -... | val partial_serialize32_list
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(u: unit{serialize_list_precond k})
: Tot (partial_serializer32 (serialize_list p s))
let partial_serialize32_list
(#t: Type)
(#k: parser_kind)
... | false | null | false | fun (input: list t {Seq.length (serialize (serialize_list p s) input) < 4294967296}) ->
((let res, _ =
partial_serialize32_list'_init p s s32 input;
CL.total_while partial_serialize32_list'_measure
(partial_serialize32_list'_inv p s s32 input)
(fun x -> partial_serialize32_list'_bo... | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"Prims.unit",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.list",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val partial_serialize32_list
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(u: unit{serialize_list_precond k})
: Tot (partial_serializer32 (serialize_list p s)) | [] | LowParse.SLow.List.partial_serialize32_list | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
s: LowParse.Spec.Base.serializer p ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
u98: u99: Prims.unit{LowParse.Spec.List.serialize_list_precond k}
-> LowParse.SLow.Base.partial_serializer32 (LowParse.Spec.List.serialize_list p s) | {
"end_col": 78,
"end_line": 365,
"start_col": 2,
"start_line": 355
} |
Prims.Tot | val size32_list
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit{serialize_list_precond k})
: Tot (size32 (serialize_list p s)) | [
{
"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... | false | let size32_list
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit {
serialize_list_precond k
})
: Tot (size32 (serialize_list p s))
= fun input ->
[@inline_let]
let (len, _) =
CL.total_while
size32_list_measure
(size32_list_inv s32 u input)
... | val size32_list
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit{serialize_list_precond k})
: Tot (size32 (serialize_list p s))
let size32_list
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
... | false | null | false | fun input ->
[@@ inline_let ]let len, _ =
CL.total_while size32_list_measure
(size32_list_inv s32 u input)
(fun x -> size32_list_body s32 u input x)
(0ul, input)
in
(len <: (len: U32.t{size32_postcond (serialize_list p s) input len})) | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.size32",
"Prims.unit",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.list",
"FStar.UInt32.t",
"LowParse.SLow.Base.size32_postcond",
"LowParse.Spec.List.parse_lis... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val size32_list
(#t: Type)
(#k: parser_kind)
(#p: parser k t)
(#s: serializer p)
(s32: size32 s)
(u: unit{serialize_list_precond k})
: Tot (size32 (serialize_list p s)) | [] | LowParse.SLow.List.size32_list | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s32: LowParse.SLow.Base.size32 s ->
u123: u124: Prims.unit{LowParse.Spec.List.serialize_list_precond k}
-> LowParse.SLow.Base.size32 (LowParse.Spec.List.serialize_list p s) | {
"end_col": 76,
"end_line": 450,
"start_col": 2,
"start_line": 441
} |
FStar.Pervasives.Lemma | val parse_list_tailrec'_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
: Lemma
(match parse (parse_list p) (B32.reveal b) with
| Some (l, n) -> parse_list_tailrec' p32 b [] == Some l
| None -> parse_list_tailrec' p32 b [] == None) | [
{
"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... | false | let parse_list_tailrec'_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
: Lemma
begin match parse (parse_list p) (B32.reveal b) with
| Some (l, n) -> parse_list_tailrec' p32 b [] == Some l
| None -> parse_list_tailrec' p32 b [] == None
end
= parse_list_tailrec'_cor... | val parse_list_tailrec'_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
: Lemma
(match parse (parse_list p) (B32.reveal b) with
| Some (l, n) -> parse_list_tailrec' p32 b [] == Some l
| None -> parse_list_tailrec' p32 b [] == None)
l... | false | null | true | parse_list_tailrec'_correct' p32 b [] | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.SLow.Base.parser32",
"LowParse.SLow.Base.bytes32",
"LowParse.SLow.List.parse_list_tailrec'_correct'",
"Prims.Nil",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Base.parse",
"Prims.list",
"LowParse.Spec.Lis... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val parse_list_tailrec'_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
: Lemma
(match parse (parse_list p) (B32.reveal b) with
| Some (l, n) -> parse_list_tailrec' p32 b [] == Some l
| None -> parse_list_tailrec' p32 b [] == None) | [] | LowParse.SLow.List.parse_list_tailrec'_correct | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p32: LowParse.SLow.Base.parser32 p -> b: LowParse.SLow.Base.bytes32
-> FStar.Pervasives.Lemma
(ensures
((match LowParse.Spec.Base.parse (LowParse.Spec.List.parse_list p) (FStar.Bytes.reveal b) with
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ l _) ->
LowPar... | {
"end_col": 39,
"end_line": 90,
"start_col": 2,
"start_line": 90
} |
Prims.Ghost | val partial_serialize32_list'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Ghost bytes32
(requires
(serialize_list_precond k /\
(Seq.length (serialize (serialize_list p s) input) < 429496729... | [
{
"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... | false | let rec partial_serialize32_list'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Ghost bytes32
(requires (
serialize_list_precond k /\ (
Seq.length (serialize (serialize_list p s) input) < 4294967296
)))
(ensures (fun (res: bytes3... | val partial_serialize32_list'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Ghost bytes32
(requires
(serialize_list_precond k /\
(Seq.length (serialize (serialize_list p s) input) < 429496729... | false | null | false | match input with
| [] ->
serialize_list_nil p s;
let res = B32.empty_bytes in
assert (Seq.equal (B32.reveal res) (Seq.empty));
res
| a :: q ->
serialize_list_cons p s a q;
let sa = s32 a in
let sq = partial_serialize32_list' p s s32 q in
let res = B32.append sa sq in
res | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"Prims.list",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Bytes.byte",
"FStar.Bytes.reveal",
"FStar.Seq.Base.empty",
"FStar.Bytes.lbytes"... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val partial_serialize32_list'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(input: list t)
: Ghost bytes32
(requires
(serialize_list_precond k /\
(Seq.length (serialize (serialize_list p s) input) < 429496729... | [
"recursion"
] | LowParse.SLow.List.partial_serialize32_list' | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
s: LowParse.Spec.Base.serializer p ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
input: Prims.list t
-> Prims.Ghost LowParse.SLow.Base.bytes32 | {
"end_col": 7,
"end_line": 238,
"start_col": 2,
"start_line": 227
} |
Prims.Ghost | val partial_serialize32_list_tailrec'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(accu: bytes32)
(input: list t)
: Ghost bytes32
(requires
(serialize_list_precond k /\
(B32.length accu + Seq.length (s... | [
{
"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... | false | let rec partial_serialize32_list_tailrec'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(accu: bytes32)
(input: list t)
: Ghost bytes32
(requires (
serialize_list_precond k /\ (
B32.length accu + Seq.length (serialize (serialize_list p s) input) < 4... | val partial_serialize32_list_tailrec'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(accu: bytes32)
(input: list t)
: Ghost bytes32
(requires
(serialize_list_precond k /\
(B32.length accu + Seq.length (s... | false | null | false | match input with
| [] ->
serialize_list_nil p s;
Seq.append_empty_r (B32.reveal accu);
accu
| a :: q ->
serialize_list_cons p s a q;
let sa = s32 a in
let accu' = B32.append accu sa in
Seq.append_assoc (B32.reveal accu)
(B32.reveal sa)
(B32.reveal (partial_serialize32_list' p s s32 q));
partial_... | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.SLow.Base.partial_serializer32",
"LowParse.SLow.Base.bytes32",
"Prims.list",
"Prims.unit",
"FStar.Seq.Base.append_empty_r",
"FStar.Bytes.byte",
"FStar.Bytes.reveal",
"LowParse.Spec.List.seri... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val partial_serialize32_list_tailrec'
(#t: Type)
(#k: parser_kind)
(p: parser k t)
(s: serializer p)
(s32: partial_serializer32 s)
(accu: bytes32)
(input: list t)
: Ghost bytes32
(requires
(serialize_list_precond k /\
(B32.length accu + Seq.length (s... | [
"recursion"
] | LowParse.SLow.List.partial_serialize32_list_tailrec' | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
s: LowParse.Spec.Base.serializer p ->
s32: LowParse.SLow.Base.partial_serializer32 s ->
accu: LowParse.SLow.Base.bytes32 ->
input: Prims.list t
-> Prims.Ghost LowParse.SLow.Base.bytes32 | {
"end_col": 53,
"end_line": 269,
"start_col": 2,
"start_line": 259
} |
FStar.Pervasives.Lemma | val parse_list_tailrec'_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: Lemma (requires True)
(ensures
(parse_list_tailrec' p32 b aux ==
(match parse (parse_list p) (B32.reveal b) with
| Som... | [
{
"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... | false | let rec parse_list_tailrec'_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: Lemma
(requires True)
(ensures (
parse_list_tailrec' p32 b aux == (
match parse (parse_list p) (B32.reveal b) with
| Some (l, n) -> Some (L.append (L.rev aux) l)
... | val parse_list_tailrec'_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: Lemma (requires True)
(ensures
(parse_list_tailrec' p32 b aux ==
(match parse (parse_list p) (B32.reveal b) with
| Som... | false | null | true | parse_list_eq p (B32.reveal b);
if B32.len b = 0ul
then L.append_l_nil (L.rev aux)
else
match p32 b with
| None -> ()
| Some (v, n) ->
if n = 0ul
then ()
else
let s = B32.slice b n (B32.len b) in
parse_list_tailrec'_correct' p32 s (v :: aux);
match parse (parse_list p) (B32.reveal s)... | {
"checked_file": "LowParse.SLow.List.fst.checked",
"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.check... | [
"lemma",
""
] | [
"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.List.Tot.Properties.append_l_nil",
"FStar.List.Tot.Base.rev",
"... | [] | 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... | false | false | LowParse.SLow.List.fst | {
"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... | null | val parse_list_tailrec'_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: parser32 p)
(b: bytes32)
(aux: list t)
: Lemma (requires True)
(ensures
(parse_list_tailrec' p32 b aux ==
(match parse (parse_list p) (B32.reveal b) with
| Som... | [
"recursion"
] | LowParse.SLow.List.parse_list_tailrec'_correct' | {
"file_name": "src/lowparse/LowParse.SLow.List.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p32: LowParse.SLow.Base.parser32 p -> b: LowParse.SLow.Base.bytes32 -> aux: Prims.list t
-> FStar.Pervasives.Lemma
(ensures
LowParse.SLow.List.parse_list_tailrec' p32 b aux ==
(match
LowParse.Spec.Base.parse (LowParse.Spec.List.parse_list p) (FStar.Bytes.reveal b)
with
... | {
"end_col": 9,
"end_line": 77,
"start_col": 2,
"start_line": 60
} |
Prims.Tot | [
{
"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",
"... | false | let reflexive (#a:Type) (rel:relation a) =
forall (x:a). rel x x | let reflexive (#a: Type) (rel: relation a) = | false | null | false | forall (x: a). rel x x | {
"checked_file": "FStar.Preorder.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
"total"
] | [
"FStar.Preorder.relation",
"Prims.l_Forall",
"Prims.logical"
] | [] | (*
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... | false | false | FStar.Preorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val reflexive : rel: FStar.Preorder.relation a -> Prims.logical | [] | FStar.Preorder.reflexive | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rel: FStar.Preorder.relation a -> Prims.logical | {
"end_col": 23,
"end_line": 25,
"start_col": 2,
"start_line": 25
} | |
Prims.Tot | [
{
"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",
"... | false | let preorder_rel (#a:Type) (rel:relation a) =
reflexive rel /\ transitive rel | let preorder_rel (#a: Type) (rel: relation a) = | false | null | false | reflexive rel /\ transitive rel | {
"checked_file": "FStar.Preorder.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
"total"
] | [
"FStar.Preorder.relation",
"Prims.l_and",
"FStar.Preorder.reflexive",
"FStar.Preorder.transitive",
"Prims.logical"
] | [] | (*
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... | false | false | FStar.Preorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val preorder_rel : rel: FStar.Preorder.relation a -> Prims.logical | [] | FStar.Preorder.preorder_rel | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rel: FStar.Preorder.relation a -> Prims.logical | {
"end_col": 33,
"end_line": 31,
"start_col": 2,
"start_line": 31
} | |
Prims.Tot | [
{
"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",
"... | false | let transitive (#a:Type) (rel:relation a) =
forall (x:a) (y:a) (z:a). (rel x y /\ rel y z) ==> rel x z | let transitive (#a: Type) (rel: relation a) = | false | null | false | forall (x: a) (y: a) (z: a). (rel x y /\ rel y z) ==> rel x z | {
"checked_file": "FStar.Preorder.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
"total"
] | [
"FStar.Preorder.relation",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.logical"
] | [] | (*
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... | false | false | FStar.Preorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val transitive : rel: FStar.Preorder.relation a -> Prims.logical | [] | FStar.Preorder.transitive | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rel: FStar.Preorder.relation a -> Prims.logical | {
"end_col": 60,
"end_line": 28,
"start_col": 2,
"start_line": 28
} | |
Prims.Tot | [
{
"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",
"... | false | 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 | let stable (#a: Type) (p: predicate a) (rel: relation a {preorder_rel rel}) = | false | null | false | forall (x: a) (y: a). (p x /\ rel x y) ==> p y | {
"checked_file": "FStar.Preorder.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Preorder.fst"
} | [
"total"
] | [
"FStar.Preorder.predicate",
"FStar.Preorder.relation",
"FStar.Preorder.preorder_rel",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.logical"
] | [] | (*
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... | false | false | FStar.Preorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val stable : p: FStar.Preorder.predicate a -> rel: FStar.Preorder.relation a {FStar.Preorder.preorder_rel rel}
-> Prims.logical | [] | FStar.Preorder.stable | {
"file_name": "ulib/FStar.Preorder.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: FStar.Preorder.predicate a -> rel: FStar.Preorder.relation a {FStar.Preorder.preorder_rel rel}
-> Prims.logical | {
"end_col": 46,
"end_line": 36,
"start_col": 2,
"start_line": 36
} | |
FStar.HyperStack.ST.Stack | val raw_to_uncompressed: pk_raw:lbuffer uint8 64ul -> pk:lbuffer uint8 65ul -> Stack unit
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 _ h1 -> modifies (loc pk) h0 h1 /\
as_seq h1 pk == S.pk_uncompressed_from_raw (as_seq h0 pk_raw)) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Point",
"short_module": "P"
},
{
"abbrev": false,
"full_m... | false | let raw_to_uncompressed pk_raw pk =
let h0 = ST.get () in
pk.(0ul) <- u8 0x04;
update_sub pk 1ul 64ul pk_raw;
let h1 = ST.get () in
LSeq.eq_intro (as_seq h1 pk) (S.pk_uncompressed_from_raw (as_seq h0 pk_raw)) | val raw_to_uncompressed: pk_raw:lbuffer uint8 64ul -> pk:lbuffer uint8 65ul -> Stack unit
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 _ h1 -> modifies (loc pk) h0 h1 /\
as_seq h1 pk == S.pk_uncompressed_from_raw (as_seq h0 pk_raw))
let raw_to_uncompressed pk_raw pk = | true | null | false | let h0 = ST.get () in
pk.(0ul) <- u8 0x04;
update_sub pk 1ul 64ul pk_raw;
let h1 = ST.get () in
LSeq.eq_intro (as_seq h1 pk) (S.pk_uncompressed_from_raw (as_seq h0 pk_raw)) | {
"checked_file": "Hacl.Impl.P256.Compression.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Spec.P256.pk_uncompressed_from_raw",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.Hyper... | [] | module Hacl.Impl.P256.Compression
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module P = Hacl.Impl.P256.Point
module S = Spec.P256
module LSeq = Lib.Sequence
module BSeq = Lib.By... | false | false | Hacl.Impl.P256.Compression.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val raw_to_uncompressed: pk_raw:lbuffer uint8 64ul -> pk:lbuffer uint8 65ul -> Stack unit
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 _ h1 -> modifies (loc pk) h0 h1 /\
as_seq h1 pk == S.pk_uncompressed_from_raw (as_seq h0 pk_raw)) | [] | Hacl.Impl.P256.Compression.raw_to_uncompressed | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Compression.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pk_raw: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 65ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 78,
"end_line": 55,
"start_col": 35,
"start_line": 50
} |
FStar.HyperStack.ST.Stack | val raw_to_compressed_get_pk0: f:lbuffer uint8 32ul -> Stack uint8
(requires fun h -> live h f)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
v b == (if (BSeq.nat_from_bytes_be (as_seq h0 f) % 2 = 1) then 0x03 else 0x02)) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hac... | false | let raw_to_compressed_get_pk0 f =
push_frame ();
let bn_f = create_felem () in
bn_from_bytes_be4 bn_f f;
let is_odd_f = bn_is_odd4 bn_f in
pop_frame ();
to_u8 is_odd_f +! u8 0x02 | val raw_to_compressed_get_pk0: f:lbuffer uint8 32ul -> Stack uint8
(requires fun h -> live h f)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
v b == (if (BSeq.nat_from_bytes_be (as_seq h0 f) % 2 = 1) then 0x03 else 0x02))
let raw_to_compressed_get_pk0 f = | true | null | false | push_frame ();
let bn_f = create_felem () in
bn_from_bytes_be4 bn_f f;
let is_odd_f = bn_is_odd4 bn_f in
pop_frame ();
to_u8 is_odd_f +! u8 0x02 | {
"checked_file": "Hacl.Impl.P256.Compression.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.to_u8",
"Lib.IntTypes.U64",
"Lib.IntTypes.u8",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.IntTypes.int_t",
"Hacl.Impl.P256.Bignum... | [] | module Hacl.Impl.P256.Compression
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module P = Hacl.Impl.P256.Point
module S = Spec.P256
module LSeq = Lib.Sequence
module BSeq = Lib.By... | false | false | Hacl.Impl.P256.Compression.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val raw_to_compressed_get_pk0: f:lbuffer uint8 32ul -> Stack uint8
(requires fun h -> live h f)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
v b == (if (BSeq.nat_from_bytes_be (as_seq h0 f) % 2 = 1) then 0x03 else 0x02)) | [] | Hacl.Impl.P256.Compression.raw_to_compressed_get_pk0 | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Compression.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.uint8 | {
"end_col": 27,
"end_line": 70,
"start_col": 2,
"start_line": 65
} |
FStar.HyperStack.ST.Stack | val uncompressed_to_raw: pk:lbuffer uint8 65ul -> pk_raw:lbuffer uint8 64ul -> Stack bool
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 b h1 -> modifies (loc pk_raw) h0 h1 /\
(b <==> Some? (S.pk_uncompressed_to_raw (as_seq h0 pk))) /\
(b ==> (as_seq h1 pk_raw == Some?.... | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Point",
"short_module": "P"
},
{
"abbrev": false,
"full_m... | false | let uncompressed_to_raw pk pk_raw =
let pk0 = pk.(0ul) in
if Lib.RawIntTypes.u8_to_UInt8 pk0 <> 0x04uy then false
else begin
copy pk_raw (sub pk 1ul 64ul);
true end | val uncompressed_to_raw: pk:lbuffer uint8 65ul -> pk_raw:lbuffer uint8 64ul -> Stack bool
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 b h1 -> modifies (loc pk_raw) h0 h1 /\
(b <==> Some? (S.pk_uncompressed_to_raw (as_seq h0 pk))) /\
(b ==> (as_seq h1 pk_raw == Some?.... | true | null | false | let pk0 = pk.(0ul) in
if Lib.RawIntTypes.u8_to_UInt8 pk0 <> 0x04uy
then false
else
(copy pk_raw (sub pk 1ul 64ul);
true) | {
"checked_file": "Hacl.Impl.P256.Compression.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Prims.op_disEquality",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_to_UInt8",
"FStar.UInt8.__uint_to_t",
"Prims.bool",
"Prims.unit",
"Lib.Buffer.copy",
"Lib.Buffer.MUT",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.Int... | [] | module Hacl.Impl.P256.Compression
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module P = Hacl.Impl.P256.Point
module S = Spec.P256
module LSeq = Lib.Sequence
module BSeq = Lib.By... | false | false | Hacl.Impl.P256.Compression.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uncompressed_to_raw: pk:lbuffer uint8 65ul -> pk_raw:lbuffer uint8 64ul -> Stack bool
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 b h1 -> modifies (loc pk_raw) h0 h1 /\
(b <==> Some? (S.pk_uncompressed_to_raw (as_seq h0 pk))) /\
(b ==> (as_seq h1 pk_raw == Some?.... | [] | Hacl.Impl.P256.Compression.uncompressed_to_raw | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Compression.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 65ul -> pk_raw: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 12,
"end_line": 26,
"start_col": 35,
"start_line": 21
} |
FStar.HyperStack.ST.Stack | val raw_to_compressed: pk_raw:lbuffer uint8 64ul -> pk:lbuffer uint8 33ul -> Stack unit
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 _ h1 -> modifies (loc pk) h0 h1 /\
as_seq h1 pk == S.pk_compressed_from_raw (as_seq h0 pk_raw)) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Point",
"short_module": "P"
},
{
"abbrev": false,
"full_m... | false | let raw_to_compressed pk_raw pk =
let h0 = ST.get () in
let pk_x = sub pk_raw 0ul 32ul in
let pk_y = sub pk_raw 32ul 32ul in
pk.(0ul) <- raw_to_compressed_get_pk0 pk_y;
update_sub pk 1ul 32ul pk_x;
let h1 = ST.get () in
LSeq.eq_intro (as_seq h1 pk) (S.pk_compressed_from_raw (as_seq h0 pk_raw)) | val raw_to_compressed: pk_raw:lbuffer uint8 64ul -> pk:lbuffer uint8 33ul -> Stack unit
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 _ h1 -> modifies (loc pk) h0 h1 /\
as_seq h1 pk == S.pk_compressed_from_raw (as_seq h0 pk_raw))
let raw_to_compressed pk_raw pk = | true | null | false | let h0 = ST.get () in
let pk_x = sub pk_raw 0ul 32ul in
let pk_y = sub pk_raw 32ul 32ul in
pk.(0ul) <- raw_to_compressed_get_pk0 pk_y;
update_sub pk 1ul 32ul pk_x;
let h1 = ST.get () in
LSeq.eq_intro (as_seq h1 pk) (S.pk_compressed_from_raw (as_seq h0 pk_raw)) | {
"checked_file": "Hacl.Impl.P256.Compression.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Spec.P256.pk_compressed_from_raw",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperSt... | [] | module Hacl.Impl.P256.Compression
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module P = Hacl.Impl.P256.Point
module S = Spec.P256
module LSeq = Lib.Sequence
module BSeq = Lib.By... | false | false | Hacl.Impl.P256.Compression.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val raw_to_compressed: pk_raw:lbuffer uint8 64ul -> pk:lbuffer uint8 33ul -> Stack unit
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 _ h1 -> modifies (loc pk) h0 h1 /\
as_seq h1 pk == S.pk_compressed_from_raw (as_seq h0 pk_raw)) | [] | Hacl.Impl.P256.Compression.raw_to_compressed | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Compression.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pk_raw: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 33ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 76,
"end_line": 80,
"start_col": 33,
"start_line": 73
} |
FStar.HyperStack.ST.Stack | val compressed_to_raw: pk:lbuffer uint8 33ul -> pk_raw:lbuffer uint8 64ul -> Stack bool
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 b h1 -> modifies (loc pk_raw) h0 h1 /\
(b <==> Some? (S.pk_compressed_to_raw (as_seq h0 pk))) /\
(b ==> (as_seq h1 pk_raw == Some?.v (... | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Point",
"short_module": "P"
},
{
"abbrev": false,
"full_m... | false | let compressed_to_raw pk pk_raw =
push_frame ();
let xa = create_felem () in
let ya = create_felem () in
let pk_xb = sub pk 1ul 32ul in
let b = P.aff_point_decompress_vartime xa ya pk in
if b then begin
let h0 = ST.get () in
update_sub pk_raw 0ul 32ul pk_xb;
let h1 = ST.get () in
update_sub... | val compressed_to_raw: pk:lbuffer uint8 33ul -> pk_raw:lbuffer uint8 64ul -> Stack bool
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 b h1 -> modifies (loc pk_raw) h0 h1 /\
(b <==> Some? (S.pk_compressed_to_raw (as_seq h0 pk))) /\
(b ==> (as_seq h1 pk_raw == Some?.v (... | true | null | false | push_frame ();
let xa = create_felem () in
let ya = create_felem () in
let pk_xb = sub pk 1ul 32ul in
let b = P.aff_point_decompress_vartime xa ya pk in
if b
then
(let h0 = ST.get () in
update_sub pk_raw 0ul 32ul pk_xb;
let h1 = ST.get () in
update_sub_f h1
pk_raw
32ul
32ul
(fun h ... | {
"checked_file": "Hacl.Impl.P256.Compression.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.Sequence.concat",
"Lib.ByteSeq... | [] | module Hacl.Impl.P256.Compression
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module P = Hacl.Impl.P256.Point
module S = Spec.P256
module LSeq = Lib.Sequence
module BSeq = Lib.By... | false | false | Hacl.Impl.P256.Compression.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val compressed_to_raw: pk:lbuffer uint8 33ul -> pk_raw:lbuffer uint8 64ul -> Stack bool
(requires fun h -> live h pk /\ live h pk_raw /\ disjoint pk pk_raw)
(ensures fun h0 b h1 -> modifies (loc pk_raw) h0 h1 /\
(b <==> Some? (S.pk_compressed_to_raw (as_seq h0 pk))) /\
(b ==> (as_seq h1 pk_raw == Some?.v (... | [] | Hacl.Impl.P256.Compression.compressed_to_raw | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Compression.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 33ul -> pk_raw: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 3,
"end_line": 47,
"start_col": 2,
"start_line": 30
} |
FStar.Pervasives.Lemma | val lemma_pow2_256: n:nat -> Lemma
(requires (n = 256))
(ensures (pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000))
[SMTPat (pow2 n)] | [
{
"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... | false | let lemma_pow2_256 n = assert_norm(pow2 256 = 0x10000000000000000000000000000000000000000000000000000000000000000) | val lemma_pow2_256: n:nat -> Lemma
(requires (n = 256))
(ensures (pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000))
[SMTPat (pow2 n)]
let lemma_pow2_256 n = | false | null | true | assert_norm (pow2 256 = 0x10000000000000000000000000000000000000000000000000000000000000000) | {
"checked_file": "Spec.Curve25519.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.Curve25519.Lemmas.fst"
} | [
"lemma"
] | [
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.pow2",
"Prims.unit"
] | [] | 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... | false | false | Spec.Curve25519.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_pow2_256: n:nat -> Lemma
(requires (n = 256))
(ensures (pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000))
[SMTPat (pow2 n)] | [] | Spec.Curve25519.Lemmas.lemma_pow2_256 | {
"file_name": "specs/lemmas/Spec.Curve25519.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Prims.nat
-> FStar.Pervasives.Lemma (requires n = 256)
(ensures Prims.pow2 n = 0x10000000000000000000000000000000000000000000000000000000000000000)
[SMTPat (Prims.pow2 n)] | {
"end_col": 114,
"end_line": 19,
"start_col": 23,
"start_line": 19
} |
FStar.Pervasives.Lemma | val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed))
[SMTPat (pow2 n - 19)] | [
{
"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... | false | let lemma_prime_value n = assert_norm(pow2 255 - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed) | val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed))
[SMTPat (pow2 n - 19)]
let lemma_prime_value n = | false | null | true | assert_norm (pow2 255 - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed) | {
"checked_file": "Spec.Curve25519.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.Curve25519.Lemmas.fst"
} | [
"lemma"
] | [
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit"
] | [] | module Spec.Curve25519.Lemmas
val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed)) | false | false | Spec.Curve25519.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_prime_value: n:nat -> Lemma
(requires (n = 255))
(ensures (pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed))
[SMTPat (pow2 n - 19)] | [] | Spec.Curve25519.Lemmas.lemma_prime_value | {
"file_name": "specs/lemmas/Spec.Curve25519.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Prims.nat
-> FStar.Pervasives.Lemma (requires n = 255)
(ensures
Prims.pow2 n - 19 = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed)
[SMTPat (Prims.pow2 n - 19)] | {
"end_col": 121,
"end_line": 7,
"start_col": 26,
"start_line": 7
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h224 = Seq.seq_of_list h224_l | let h224 = | false | null | false | Seq.seq_of_list h224_l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"FStar.Seq.Properties.seq_of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Spec.SHA2.Constants.h224_l"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h224 : s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h224_l = FStar.Seq.Base.length s} | [] | Spec.SHA2.Constants.h224 | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h224_l = FStar.Seq.Base.length s} | {
"end_col": 33,
"end_line": 77,
"start_col": 11,
"start_line": 77
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let k384_512 = Seq.seq_of_list k384_512_l | let k384_512 = | false | null | false | Seq.seq_of_list k384_512_l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"FStar.Seq.Properties.seq_of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA2.Constants.k384_512_l"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val k384_512 : s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.k384_512_l = FStar.Seq.Base.length s} | [] | Spec.SHA2.Constants.k384_512 | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.k384_512_l = FStar.Seq.Base.length s} | {
"end_col": 41,
"end_line": 62,
"start_col": 15,
"start_line": 62
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h256 = Seq.seq_of_list h256_l | let h256 = | false | null | false | Seq.seq_of_list h256_l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"FStar.Seq.Properties.seq_of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Spec.SHA2.Constants.h256_l"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h256 : s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h256_l = FStar.Seq.Base.length s} | [] | Spec.SHA2.Constants.h256 | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h256_l = FStar.Seq.Base.length s} | {
"end_col": 33,
"end_line": 90,
"start_col": 11,
"start_line": 90
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h384 = Seq.seq_of_list h384_l | let h384 = | false | null | false | Seq.seq_of_list h384_l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"FStar.Seq.Properties.seq_of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA2.Constants.h384_l"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h384 : s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h384_l = FStar.Seq.Base.length s} | [] | Spec.SHA2.Constants.h384 | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h384_l = FStar.Seq.Base.length s} | {
"end_col": 33,
"end_line": 103,
"start_col": 11,
"start_line": 103
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h512 = Seq.seq_of_list h512_l | let h512 = | false | null | false | Seq.seq_of_list h512_l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"FStar.Seq.Properties.seq_of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA2.Constants.h512_l"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h512 : s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h512_l = FStar.Seq.Base.length s} | [] | Spec.SHA2.Constants.h512 | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.h512_l = FStar.Seq.Base.length s} | {
"end_col": 33,
"end_line": 116,
"start_col": 11,
"start_line": 116
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let k224_256 = Seq.seq_of_list k224_256_l | let k224_256 = | false | null | false | Seq.seq_of_list k224_256_l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"FStar.Seq.Properties.seq_of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Spec.SHA2.Constants.k224_256_l"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val k224_256 : s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.k224_256_l = FStar.Seq.Base.length s} | [] | Spec.SHA2.Constants.k224_256 | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s:
FStar.Seq.Base.seq (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length Spec.SHA2.Constants.k224_256_l = FStar.Seq.Base.length s} | {
"end_col": 41,
"end_line": 31,
"start_col": 15,
"start_line": 31
} | |
Prims.Tot | val h256_l:List.llist uint32 8 | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h256_l: List.llist uint32 8 =
[@inline_let]
let l =
[u32 0x6a09e667; u32 0xbb67ae85; u32 0x3c6ef372; u32 0xa54ff53a;
u32 0x510e527f; u32 0x9b05688c; u32 0x1f83d9ab; u32 0x5be0cd19]
in
assert_norm (List.length l = 8);
l | val h256_l:List.llist uint32 8
let h256_l:List.llist uint32 8 = | false | null | false | [@@ inline_let ]let l =
[
u32 0x6a09e667;
u32 0xbb67ae85;
u32 0x3c6ef372;
u32 0xa54ff53a;
u32 0x510e527f;
u32 0x9b05688c;
u32 0x1f83d9ab;
u32 0x5be0cd19
]
in
assert_norm (List.length l = 8);
l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u32",
"Prims.Nil"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h256_l:List.llist uint32 8 | [] | Spec.SHA2.Constants.h256_l | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC) 8 | {
"end_col": 3,
"end_line": 88,
"start_col": 2,
"start_line": 82
} |
Prims.Tot | val h224_l:List.llist uint32 8 | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h224_l: List.llist uint32 8 =
[@inline_let]
let l = [
u32 0xc1059ed8; u32 0x367cd507; u32 0x3070dd17; u32 0xf70e5939;
u32 0xffc00b31; u32 0x68581511; u32 0x64f98fa7; u32 0xbefa4fa4
] in
assert_norm (List.length l = 8);
l | val h224_l:List.llist uint32 8
let h224_l:List.llist uint32 8 = | false | null | false | [@@ inline_let ]let l =
[
u32 0xc1059ed8;
u32 0x367cd507;
u32 0x3070dd17;
u32 0xf70e5939;
u32 0xffc00b31;
u32 0x68581511;
u32 0x64f98fa7;
u32 0xbefa4fa4
]
in
assert_norm (List.length l = 8);
l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u32",
"Prims.Nil"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h224_l:List.llist uint32 8 | [] | Spec.SHA2.Constants.h224_l | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC) 8 | {
"end_col": 3,
"end_line": 75,
"start_col": 2,
"start_line": 69
} |
Prims.Tot | val h512_l:List.llist uint64 8 | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h512_l: List.llist uint64 8 =
[@inline_let]
let l = [
u64 0x6a09e667f3bcc908; u64 0xbb67ae8584caa73b; u64 0x3c6ef372fe94f82b; u64 0xa54ff53a5f1d36f1;
u64 0x510e527fade682d1; u64 0x9b05688c2b3e6c1f; u64 0x1f83d9abfb41bd6b; u64 0x5be0cd19137e2179
] in
assert_norm (List.length l = 8);
l | val h512_l:List.llist uint64 8
let h512_l:List.llist uint64 8 = | false | null | false | [@@ inline_let ]let l =
[
u64 0x6a09e667f3bcc908;
u64 0xbb67ae8584caa73b;
u64 0x3c6ef372fe94f82b;
u64 0xa54ff53a5f1d36f1;
u64 0x510e527fade682d1;
u64 0x9b05688c2b3e6c1f;
u64 0x1f83d9abfb41bd6b;
u64 0x5be0cd19137e2179
]
in
assert_norm (List.length l = 8);
l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u64",
"Prims.Nil"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h512_l:List.llist uint64 8 | [] | Spec.SHA2.Constants.h512_l | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC) 8 | {
"end_col": 3,
"end_line": 114,
"start_col": 2,
"start_line": 108
} |
Prims.Tot | val h384_l:List.llist uint64 8 | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let h384_l: List.llist uint64 8 =
[@inline_let]
let l = [
u64 0xcbbb9d5dc1059ed8; u64 0x629a292a367cd507; u64 0x9159015a3070dd17; u64 0x152fecd8f70e5939;
u64 0x67332667ffc00b31; u64 0x8eb44a8768581511; u64 0xdb0c2e0d64f98fa7; u64 0x47b5481dbefa4fa4
] in
assert_norm (List.length l = 8);
l | val h384_l:List.llist uint64 8
let h384_l:List.llist uint64 8 = | false | null | false | [@@ inline_let ]let l =
[
u64 0xcbbb9d5dc1059ed8;
u64 0x629a292a367cd507;
u64 0x9159015a3070dd17;
u64 0x152fecd8f70e5939;
u64 0x67332667ffc00b31;
u64 0x8eb44a8768581511;
u64 0xdb0c2e0d64f98fa7;
u64 0x47b5481dbefa4fa4
]
in
assert_norm (List.length l = 8);
l | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u64",
"Prims.Nil"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val h384_l:List.llist uint64 8 | [] | Spec.SHA2.Constants.h384_l | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC) 8 | {
"end_col": 3,
"end_line": 101,
"start_col": 2,
"start_line": 95
} |
Prims.Tot | val k224_256_l:List.llist uint32 64 | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x923f82a4; u32 0xab1c5ed5;
u32 0xd807aa98; u32 0x12835b01; u32 0x243185be; u32 0x550c7dc3;
u32 0x72be5d74; u32 0x80deb1fe; u32 0x9bdc0... | val k224_256_l:List.llist uint32 64
let k224_256_l:List.llist uint32 64 = | false | null | false | [@@ inline_let ]let l =
[
u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5; u32 0x3956c25b; u32 0x59f111f1;
u32 0x923f82a4; u32 0xab1c5ed5; u32 0xd807aa98; u32 0x12835b01; u32 0x243185be; u32 0x550c7dc3;
u32 0x72be5d74; u32 0x80deb1fe; u32 0x9bdc06a7; u32 0xc19bf174; u32 0xe49b69c1; u32 0xef... | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u32",
"Prims.Nil"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val k224_256_l:List.llist uint32 64 | [] | Spec.SHA2.Constants.k224_256_l | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.SEC) 64 | {
"end_col": 3,
"end_line": 29,
"start_col": 2,
"start_line": 10
} |
Prims.Tot | val k384_512_l:List.llist uint64 80 | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | false | let k384_512_l: List.llist uint64 80 =
[@inline_let]
let l =
[u64 0x428a2f98d728ae22; u64 0x7137449123ef65cd; u64 0xb5c0fbcfec4d3b2f; u64 0xe9b5dba58189dbbc;
u64 0x3956c25bf348b538; u64 0x59f111f1b605d019; u64 0x923f82a4af194f9b; u64 0xab1c5ed5da6d8118;
u64 0xd807aa98a3030242; u64 0x12835b0145706fbe; ... | val k384_512_l:List.llist uint64 80
let k384_512_l:List.llist uint64 80 = | false | null | false | [@@ inline_let ]let l =
[
u64 0x428a2f98d728ae22; u64 0x7137449123ef65cd; u64 0xb5c0fbcfec4d3b2f; u64 0xe9b5dba58189dbbc;
u64 0x3956c25bf348b538; u64 0x59f111f1b605d019; u64 0x923f82a4af194f9b; u64 0xab1c5ed5da6d8118;
u64 0xd807aa98a3030242; u64 0x12835b0145706fbe; u64 0x243185be4ee4b28c; u64 0x550c7dc3d5... | {
"checked_file": "Spec.SHA2.Constants.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA2.Constants.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u64",
"Prims.Nil"
] | [] | module Spec.SHA2.Constants
#set-options "--z3rlimit 100"
open Lib.IntTypes
// K shuffling vectors
[@"opaque_to_smt"]
inline_for_extraction
let k224_256_l: List.llist uint32 64 =
[@inline_let]
let l =
[u32 0x428a2f98; u32 0x71374491; u32 0xb5c0fbcf; u32 0xe9b5dba5;
u32 0x3956c25b; u32 0x59f111f1; u32 0x92... | false | false | Spec.SHA2.Constants.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val k384_512_l:List.llist uint64 80 | [] | Spec.SHA2.Constants.k384_512_l | {
"file_name": "specs/Spec.SHA2.Constants.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.SEC) 80 | {
"end_col": 3,
"end_line": 60,
"start_col": 2,
"start_line": 36
} |
Prims.Tot | val on_range (p: (nat -> vprop)) (i j: nat) : vprop | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | false | let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j | val on_range (p: (nat -> vprop)) (i j: nat) : vprop
let rec on_range (p: (nat -> vprop)) (i j: nat)
: Tot vprop (decreases (if j <= i then 0 else j - i)) = | false | null | false | if j < i then pure False else if j = i then emp else (p i) `star` (on_range p (i + 1) j) | {
"checked_file": "Steel.ST.OnRange.fst.checked",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [
"",
"total"
] | [
"Prims.nat",
"Steel.Effect.Common.vprop",
"Prims.op_LessThan",
"Steel.ST.Util.pure",
"Prims.l_False",
"Prims.bool",
"Prims.op_Equality",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.star",
"Steel.ST.OnRange.on_range",
"Prims.op_Addition"
] | [] | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop | false | true | Steel.ST.OnRange.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val on_range (p: (nat -> vprop)) (i j: nat) : vprop | [
"recursion"
] | Steel.ST.OnRange.on_range | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat
-> Prims.Tot Steel.Effect.Common.vprop | {
"end_col": 38,
"end_line": 13,
"start_col": 2,
"start_line": 9
} |
Steel.ST.Effect.Ghost.STGhost | val on_range_empty
(#opened: _)
(p: (nat -> vprop))
(i: nat)
(j: nat)
: STGhost unit opened
emp
(fun _ -> on_range p i j)
(i == j)
(fun _ -> True) | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | false | let on_range_empty
p i j
= rewrite emp (on_range p i j) | val on_range_empty
(#opened: _)
(p: (nat -> vprop))
(i: nat)
(j: nat)
: STGhost unit opened
emp
(fun _ -> on_range p i j)
(i == j)
(fun _ -> True)
let on_range_empty p i j = | true | null | false | rewrite emp (on_range p i j) | {
"checked_file": "Steel.ST.OnRange.fst.checked",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [] | [
"Steel.Memory.inames",
"Prims.nat",
"Steel.Effect.Common.vprop",
"Steel.ST.Util.rewrite",
"Steel.Effect.Common.emp",
"Steel.ST.OnRange.on_range",
"Prims.unit"
] | [] | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j
let on_range_le
p i j
= if i <= j
then noop ()
else begin
r... | false | false | Steel.ST.OnRange.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val on_range_empty
(#opened: _)
(p: (nat -> vprop))
(i: nat)
(j: nat)
: STGhost unit opened
emp
(fun _ -> on_range p i j)
(i == j)
(fun _ -> True) | [] | Steel.ST.OnRange.on_range_empty | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | {
"end_col": 30,
"end_line": 28,
"start_col": 2,
"start_line": 28
} |
Steel.ST.Effect.Ghost.STGhost | val on_range_singleton_elim
(#opened: _)
(p: (nat -> vprop))
(i j: nat)
: STGhost unit opened
(on_range p i j)
(fun _ -> p i)
(j == i + 1)
(fun _ -> True) | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | false | let on_range_singleton_elim
p i j
= rewrite (on_range p i j) (p i `star` emp) | val on_range_singleton_elim
(#opened: _)
(p: (nat -> vprop))
(i j: nat)
: STGhost unit opened
(on_range p i j)
(fun _ -> p i)
(j == i + 1)
(fun _ -> True)
let on_range_singleton_elim p i j = | true | null | false | rewrite (on_range p i j) ((p i) `star` emp) | {
"checked_file": "Steel.ST.OnRange.fst.checked",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [] | [
"Steel.Memory.inames",
"Prims.nat",
"Steel.Effect.Common.vprop",
"Steel.ST.Util.rewrite",
"Steel.ST.OnRange.on_range",
"Steel.Effect.Common.star",
"Steel.Effect.Common.emp",
"Prims.unit"
] | [] | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j
let on_range_le
p i j
= if i <= j
then noop ()
else begin
r... | false | false | Steel.ST.OnRange.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val on_range_singleton_elim
(#opened: _)
(p: (nat -> vprop))
(i j: nat)
: STGhost unit opened
(on_range p i j)
(fun _ -> p i)
(j == i + 1)
(fun _ -> True) | [] | Steel.ST.OnRange.on_range_singleton_elim | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | {
"end_col": 43,
"end_line": 36,
"start_col": 2,
"start_line": 36
} |
Steel.ST.Effect.Ghost.STGhost | val on_range_singleton_intro
(#opened: _)
(p: (nat -> vprop))
(i: nat)
(j: nat)
: STGhost unit opened
(p i)
(fun _ -> on_range p i j)
(j == i + 1)
(fun _ -> True) | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | false | let on_range_singleton_intro
p i j
= rewrite (p i `star` emp) (on_range p i j) | val on_range_singleton_intro
(#opened: _)
(p: (nat -> vprop))
(i: nat)
(j: nat)
: STGhost unit opened
(p i)
(fun _ -> on_range p i j)
(j == i + 1)
(fun _ -> True)
let on_range_singleton_intro p i j = | true | null | false | rewrite ((p i) `star` emp) (on_range p i j) | {
"checked_file": "Steel.ST.OnRange.fst.checked",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [] | [
"Steel.Memory.inames",
"Prims.nat",
"Steel.Effect.Common.vprop",
"Steel.ST.Util.rewrite",
"Steel.Effect.Common.star",
"Steel.Effect.Common.emp",
"Steel.ST.OnRange.on_range",
"Prims.unit"
] | [] | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j
let on_range_le
p i j
= if i <= j
then noop ()
else begin
r... | false | false | Steel.ST.OnRange.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val on_range_singleton_intro
(#opened: _)
(p: (nat -> vprop))
(i: nat)
(j: nat)
: STGhost unit opened
(p i)
(fun _ -> on_range p i j)
(j == i + 1)
(fun _ -> True) | [] | Steel.ST.OnRange.on_range_singleton_intro | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | {
"end_col": 43,
"end_line": 32,
"start_col": 2,
"start_line": 32
} |
Steel.ST.Effect.Ghost.STGhost | val on_range_split
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhost unit opened
(on_range p i k)
(fun _ -> on_range p i j `star` on_range p j k)
(i <= j /\ j <= k)
(fun _ -> True) | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | false | let rec on_range_split
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhost unit opened
(on_range p i k)
(fun _ -> on_range p i j `star` on_range p j k)
(i <= j /\ j <= k)
(fun _ -> True)
(decreases (j - i))
= if i = j
then begin
rewrite emp (on_range p i j);
rewrite (on_range p i... | val on_range_split
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhost unit opened
(on_range p i k)
(fun _ -> on_range p i j `star` on_range p j k)
(i <= j /\ j <= k)
(fun _ -> True)
let rec on_range_split (#opened: _) (p: (nat -> vprop)) (i j k: nat)
: STGhost unit
opened
(on_... | true | null | false | if i = j
then
(rewrite emp (on_range p i j);
rewrite (on_range p i k) (on_range p j k))
else
(rewrite (on_range p i k) ((p i) `star` (on_range p (i + 1) k));
on_range_split p (i + 1) j k;
rewrite ((p i) `star` (on_range p (i + 1) j)) (on_range p i j)) | {
"checked_file": "Steel.ST.OnRange.fst.checked",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [
""
] | [
"Steel.Memory.inames",
"Prims.nat",
"Steel.Effect.Common.vprop",
"Prims.op_Equality",
"Steel.ST.Util.rewrite",
"Steel.ST.OnRange.on_range",
"Prims.unit",
"Steel.Effect.Common.emp",
"Prims.bool",
"Steel.Effect.Common.star",
"Prims.op_Addition",
"Steel.ST.OnRange.on_range_split",
"Prims.l_and"... | [] | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j
let on_range_le
p i j
= if i <= j
then noop ()
else begin
r... | false | false | Steel.ST.OnRange.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val on_range_split
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhost unit opened
(on_range p i k)
(fun _ -> on_range p i j `star` on_range p j k)
(i <= j /\ j <= k)
(fun _ -> True) | [
"recursion"
] | Steel.ST.OnRange.on_range_split | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat -> k: Prims.nat
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | {
"end_col": 5,
"end_line": 56,
"start_col": 2,
"start_line": 48
} |
Steel.ST.Effect.Ghost.STGhostT | val on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k) | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | false | let rec on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k)
(decreases (if j >= i then j - i else 0))
= on_range_le p i j;
on_range_le p j k;
if i = j
then begin
rewrite (on_range p i j) emp;
... | val on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k)
let rec on_range_join (#opened: _) (p: (nat -> vprop)) (i j k: nat)
: STGhostT unit
opened
((on_range p i j) `star` (on_range p j k))
... | true | null | false | on_range_le p i j;
on_range_le p j k;
if i = j
then
(rewrite (on_range p i j) emp;
rewrite (on_range p j k) (on_range p i k))
else
(rewrite (on_range p i j) ((p i) `star` (on_range p (i + 1) j));
on_range_join p (i + 1) j k;
rewrite ((p i) `star` (on_range p (i + 1) k)) (on_range p i k)) | {
"checked_file": "Steel.ST.OnRange.fst.checked",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [
""
] | [
"Steel.Memory.inames",
"Prims.nat",
"Steel.Effect.Common.vprop",
"Prims.op_Equality",
"Steel.ST.Util.rewrite",
"Steel.ST.OnRange.on_range",
"Prims.unit",
"Steel.Effect.Common.emp",
"Prims.bool",
"Steel.Effect.Common.star",
"Prims.op_Addition",
"Steel.ST.OnRange.on_range_join",
"Steel.ST.OnRa... | [] | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j
let on_range_le
p i j
= if i <= j
then noop ()
else begin
r... | false | false | Steel.ST.OnRange.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k) | [
"recursion"
] | Steel.ST.OnRange.on_range_join | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat -> k: Prims.nat
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | {
"end_col": 5,
"end_line": 76,
"start_col": 2,
"start_line": 66
} |
Prims.Tot | val bn_check_modulus_u32 (len: BN.meta_len U32) : bn_check_modulus_st U32 len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_... | false | let bn_check_modulus_u32 (len:BN.meta_len U32) : bn_check_modulus_st U32 len =
bn_check_modulus #U32 #len | val bn_check_modulus_u32 (len: BN.meta_len U32) : bn_check_modulus_st U32 len
let bn_check_modulus_u32 (len: BN.meta_len U32) : bn_check_modulus_st U32 len = | false | null | false | bn_check_modulus #U32 #len | {
"checked_file": "Hacl.Bignum.Montgomery.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Lib.IntTypes.U32",
"Hacl.Bignum.Montgomery.bn_check_modulus",
"Hacl.Bignum.Montgomery.bn_check_modulus_st"
] | [] | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Sp... | false | false | Hacl.Bignum.Montgomery.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_check_modulus_u32 (len: BN.meta_len U32) : bn_check_modulus_st U32 len | [] | Hacl.Bignum.Montgomery.bn_check_modulus_u32 | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Lib.IntTypes.U32
-> Hacl.Bignum.Montgomery.bn_check_modulus_st Lib.IntTypes.U32 len | {
"end_col": 28,
"end_line": 182,
"start_col": 2,
"start_line": 182
} |
Prims.Tot | val bn_check_modulus_u64 (len: BN.meta_len U64) : bn_check_modulus_st U64 len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_... | false | let bn_check_modulus_u64 (len:BN.meta_len U64) : bn_check_modulus_st U64 len =
bn_check_modulus #U64 #len | val bn_check_modulus_u64 (len: BN.meta_len U64) : bn_check_modulus_st U64 len
let bn_check_modulus_u64 (len: BN.meta_len U64) : bn_check_modulus_st U64 len = | false | null | false | bn_check_modulus #U64 #len | {
"checked_file": "Hacl.Bignum.Montgomery.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Lib.IntTypes.U64",
"Hacl.Bignum.Montgomery.bn_check_modulus",
"Hacl.Bignum.Montgomery.bn_check_modulus_st"
] | [] | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Sp... | false | false | Hacl.Bignum.Montgomery.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_check_modulus_u64 (len: BN.meta_len U64) : bn_check_modulus_st U64 len | [] | Hacl.Bignum.Montgomery.bn_check_modulus_u64 | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Lib.IntTypes.U64
-> Hacl.Bignum.Montgomery.bn_check_modulus_st Lib.IntTypes.U64 len | {
"end_col": 28,
"end_line": 210,
"start_col": 2,
"start_line": 210
} |
Prims.Tot | val bn_precomp_r2_mod_n_u64 (len: BN.meta_len U64) : bn_precomp_r2_mod_n_st U64 len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_... | false | let bn_precomp_r2_mod_n_u64 (len:BN.meta_len U64) : bn_precomp_r2_mod_n_st U64 len =
bn_precomp_r2_mod_n (BN.mk_runtime_bn U64 len) | val bn_precomp_r2_mod_n_u64 (len: BN.meta_len U64) : bn_precomp_r2_mod_n_st U64 len
let bn_precomp_r2_mod_n_u64 (len: BN.meta_len U64) : bn_precomp_r2_mod_n_st U64 len = | false | null | false | bn_precomp_r2_mod_n (BN.mk_runtime_bn U64 len) | {
"checked_file": "Hacl.Bignum.Montgomery.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Lib.IntTypes.U64",
"Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n",
"Hacl.Bignum.mk_runtime_bn",
"Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n_st"
] | [] | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Sp... | false | false | Hacl.Bignum.Montgomery.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_precomp_r2_mod_n_u64 (len: BN.meta_len U64) : bn_precomp_r2_mod_n_st U64 len | [] | Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n_u64 | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Lib.IntTypes.U64
-> Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n_st Lib.IntTypes.U64 len | {
"end_col": 48,
"end_line": 212,
"start_col": 2,
"start_line": 212
} |
Prims.Tot | val bn_mont_one:
#t:limb_t
-> len:BN.meta_len t
-> bn_mont_from:bn_from_mont_st t len ->
bn_mont_one_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_... | false | let bn_mont_one #t len bn_from_mont n mu r2 oneM =
bn_from_mont n mu r2 oneM | val bn_mont_one:
#t:limb_t
-> len:BN.meta_len t
-> bn_mont_from:bn_from_mont_st t len ->
bn_mont_one_st t len
let bn_mont_one #t len bn_from_mont n mu r2 oneM = | false | null | false | bn_from_mont n mu r2 oneM | {
"checked_file": "Hacl.Bignum.Montgomery.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",... | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Montgomery.bn_from_mont_st",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit"
] | [] | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Sp... | false | false | Hacl.Bignum.Montgomery.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_mont_one:
#t:limb_t
-> len:BN.meta_len t
-> bn_mont_from:bn_from_mont_st t len ->
bn_mont_one_st t len | [] | Hacl.Bignum.Montgomery.bn_mont_one | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len t -> bn_mont_from: Hacl.Bignum.Montgomery.bn_from_mont_st t len
-> Hacl.Bignum.Montgomery.bn_mont_one_st t len | {
"end_col": 27,
"end_line": 245,
"start_col": 2,
"start_line": 245
} |
Prims.Tot | val bn_mont_sqr_u64 (len: BN.meta_len U64) : bn_mont_sqr_st U64 len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_... | false | let bn_mont_sqr_u64 (len:BN.meta_len U64) : bn_mont_sqr_st U64 len =
bn_mont_sqr (BN.mk_runtime_bn U64 len) (bn_mont_reduction_u64 len) | val bn_mont_sqr_u64 (len: BN.meta_len U64) : bn_mont_sqr_st U64 len
let bn_mont_sqr_u64 (len: BN.meta_len U64) : bn_mont_sqr_st U64 len = | false | null | false | bn_mont_sqr (BN.mk_runtime_bn U64 len) (bn_mont_reduction_u64 len) | {
"checked_file": "Hacl.Bignum.Montgomery.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Lib.IntTypes.U64",
"Hacl.Bignum.Montgomery.bn_mont_sqr",
"Hacl.Bignum.mk_runtime_bn",
"Hacl.Bignum.Montgomery.bn_mont_reduction_u64",
"Hacl.Bignum.Montgomery.bn_mont_sqr_st"
] | [] | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Sp... | false | false | Hacl.Bignum.Montgomery.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_mont_sqr_u64 (len: BN.meta_len U64) : bn_mont_sqr_st U64 len | [] | Hacl.Bignum.Montgomery.bn_mont_sqr_u64 | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Lib.IntTypes.U64
-> Hacl.Bignum.Montgomery.bn_mont_sqr_st Lib.IntTypes.U64 len | {
"end_col": 68,
"end_line": 222,
"start_col": 2,
"start_line": 222
} |
Prims.Tot | val bn_precomp_r2_mod_n_u32 (len: BN.meta_len U32) : bn_precomp_r2_mod_n_st U32 len | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_... | false | let bn_precomp_r2_mod_n_u32 (len:BN.meta_len U32) : bn_precomp_r2_mod_n_st U32 len =
bn_precomp_r2_mod_n (BN.mk_runtime_bn U32 len) | val bn_precomp_r2_mod_n_u32 (len: BN.meta_len U32) : bn_precomp_r2_mod_n_st U32 len
let bn_precomp_r2_mod_n_u32 (len: BN.meta_len U32) : bn_precomp_r2_mod_n_st U32 len = | false | null | false | bn_precomp_r2_mod_n (BN.mk_runtime_bn U32 len) | {
"checked_file": "Hacl.Bignum.Montgomery.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",... | [
"total"
] | [
"Hacl.Bignum.meta_len",
"Lib.IntTypes.U32",
"Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n",
"Hacl.Bignum.mk_runtime_bn",
"Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n_st"
] | [] | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Sp... | false | false | Hacl.Bignum.Montgomery.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_precomp_r2_mod_n_u32 (len: BN.meta_len U32) : bn_precomp_r2_mod_n_st U32 len | [] | Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n_u32 | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Bignum.meta_len Lib.IntTypes.U32
-> Hacl.Bignum.Montgomery.bn_precomp_r2_mod_n_st Lib.IntTypes.U32 len | {
"end_col": 48,
"end_line": 184,
"start_col": 2,
"start_line": 184
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.