file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_Bind_t | val wp_Bind_t : a: Type0 -> Type | let wp_Bind_t (a:Type0) = va_state -> a -> Type0 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 100,
"start_col": 0,
"start_line": 100
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type0 -> Type | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_state"
] | [] | false | false | false | true | true | let wp_Bind_t (a: Type0) =
| va_state -> a -> Type0 | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_range1 | val va_range1 : FStar.Range.range | let va_range1 = mk_range "" 0 0 0 0 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 104,
"start_col": 0,
"start_line": 104
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | FStar.Range.range | Prims.Tot | [
"total"
] | [] | [
"FStar.Range.mk_range"
] | [] | false | false | false | true | false | let va_range1 =
| mk_range "" 0 0 0 0 | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_block | val wp_block
(#a: Type)
(#cs: codes)
(qcs: (va_state -> GTot (quickCodes a cs)))
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | val wp_block
(#a: Type)
(#cs: codes)
(qcs: (va_state -> GTot (quickCodes a cs)))
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | let wp_block (#a:Type) (#cs:codes) (qcs:va_state -> GTot (quickCodes a cs)) (mods:mods_t) (s0:va_state) (k:va_state -> a -> Type0) : Type0 =
wp cs (qcs s0) mods k s0 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 172,
"start_col": 0,
"start_line": 171
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
qcs: (_: Vale.X64.Decls.va_state -> Prims.GTot (Vale.X64.QuickCodes.quickCodes a cs)) ->
mods: Vale.X64.QuickCode.mods_t ->
s0: Vale.X64.Decls.va_state ->
k: (_: Vale.X64.Decls.va_state -> _: a -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.QuickCodes.wp"
] | [] | false | false | false | false | true | let wp_block
(#a: Type)
(#cs: codes)
(qcs: (va_state -> GTot (quickCodes a cs)))
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 =
| wp cs (qcs s0) mods k s0 | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.k_AssertBy | val k_AssertBy : p: Type0 -> _: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0 | let k_AssertBy (p:Type0) (_:va_state) () = p | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 101,
"start_col": 0,
"start_line": 101
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Type0 -> _: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_state",
"Prims.unit"
] | [] | false | false | false | true | true | let k_AssertBy (p: Type0) (_: va_state) () =
| p | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_If | val wp_If
(#a: Type)
(#c1 #c2: code)
(b: cmp)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | val wp_If
(#a: Type)
(#c1 #c2: code)
(b: cmp)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | let wp_If (#a:Type) (#c1:code) (#c2:code) (b:cmp) (qc1:quickCode a c1) (qc2:quickCode a c2) (mods:mods_t) (s0:va_state) (k:va_state -> a -> Type0) : Type0 =
// REVIEW: this duplicates k
valid_cmp b s0 /\ mods_contains1 mods Mod_flags /\
(let s1 = va_upd_flags havoc_flags s0 in
( eval_cmp s0 b ==> mods_co... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 80,
"end_line": 248,
"start_col": 0,
"start_line": 243
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Vale.X64.QuickCodes.cmp ->
qc1: Vale.X64.QuickCode.quickCode a c1 ->
qc2: Vale.X64.QuickCode.quickCode a c2 ->
mods: Vale.X64.QuickCode.mods_t ->
s0: Vale.X64.Decls.va_state ->
k: (_: Vale.X64.Decls.va_state -> _: a -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCodes.cmp",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Vale.X64.QuickCodes.valid_cmp",
"Prims.b2t",
"Vale.X64.QuickCodes.mods_contains1",
"Vale.X64.QuickCode.Mod_flags",
"Prims.l_imp",
"Vale... | [] | false | false | false | false | true | let wp_If
(#a: Type)
(#c1 #c2: code)
(b: cmp)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 =
| valid_cmp b s0 /\ mods_contains1 mods Mod_flags /\
(let s1 = va_upd_flags havoc_flags s0 in
(eval_cmp s0 b ==> mods_contains mods qc1.mods /\ QProc?.wp qc1 s1 k) /\
(not (eval_cmp s0 b) ==> mods_contains mods qc2.mods /\ QProc?.wp qc2 s1 k)) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_Seq_t | val wp_Seq_t : a: Type0 -> Type | let wp_Seq_t (a:Type0) = va_state -> a -> Type0 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 99,
"start_col": 0,
"start_line": 99
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type0 -> Type | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_state"
] | [] | false | false | false | true | true | let wp_Seq_t (a: Type0) =
| va_state -> a -> Type0 | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_InlineIf | val wp_InlineIf
(#a: Type)
(#c1 #c2: code)
(b: bool)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | val wp_InlineIf
(#a: Type)
(#c1 #c2: code)
(b: bool)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | let wp_InlineIf (#a:Type) (#c1:code) (#c2:code) (b:bool) (qc1:quickCode a c1) (qc2:quickCode a c2) (mods:mods_t) (s0:va_state) (k:va_state -> a -> Type0) : Type0 =
// REVIEW: this duplicates k
( b ==> mods_contains mods qc1.mods /\ QProc?.wp qc1 s0 k) /\
(not b ==> mods_contains mods qc2.mods /\ QProc?.wp qc2 ... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 191,
"start_col": 0,
"start_line": 188
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Prims.bool ->
qc1: Vale.X64.QuickCode.quickCode a c1 ->
qc2: Vale.X64.QuickCode.quickCode a c2 ->
mods: Vale.X64.QuickCode.mods_t ->
s0: Vale.X64.Decls.va_state ->
k: (_: Vale.X64.Decls.va_state -> _: a -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Prims.bool",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Vale.X64.QuickCodes.mods_contains",
"Vale.X64.QuickCode.__proj__QProc__item__mods",
"Vale.X64.QuickCode.__proj__QProc__ite... | [] | false | false | false | false | true | let wp_InlineIf
(#a: Type)
(#c1 #c2: code)
(b: bool)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
(mods: mods_t)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 =
| (b ==> mods_contains mods qc1.mods /\ QProc?.wp qc1 s0 k) /\
(not b ==> mods_contains mods qc2.mods /\ QProc?.wp qc2 s0 k) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_While_body | val wp_While_body
(#a #d: Type)
(#c: code)
(b: cmp)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g1: a)
(s1: va_state)
(k: (va_state -> a -> Type0))
: Type0 | val wp_While_body
(#a #d: Type)
(#c: code)
(b: cmp)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g1: a)
(s1: va_state)
(k: (va_state -> a -> Type0))
: Type0 | let wp_While_body
(#a #d:Type) (#c:code) (b:cmp) (qc:a -> quickCode a c) (mods:mods_t) (inv:va_state -> a -> Type0)
(dec:va_state -> a -> d) (g1:a) (s1:va_state) (k:va_state -> a -> Type0)
: Type0 =
valid_cmp b s1 /\
(let s1' = va_upd_flags havoc_flags s1 in
( eval_cmp s1 b ==> mods_contains mo... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 278,
"start_col": 0,
"start_line": 271
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Vale.X64.QuickCodes.cmp ->
qc: (_: a -> Vale.X64.QuickCode.quickCode a c) ->
mods: Vale.X64.QuickCode.mods_t ->
inv: (_: Vale.X64.Decls.va_state -> _: a -> Type0) ->
dec: (_: Vale.X64.Decls.va_state -> _: a -> d) ->
g1: a ->
s1: Vale.X64.Decls.va_state ->
k: (_: Vale.X64.Decls.va_sta... | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCodes.cmp",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Vale.X64.QuickCodes.valid_cmp",
"Prims.l_imp",
"Prims.b2t",
"Vale.X64.QuickCodes.eval_cmp",
"Vale.X64.QuickCodes.mods_contains",
"Vale.... | [] | false | false | false | false | true | let wp_While_body
(#a #d: Type)
(#c: code)
(b: cmp)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g1: a)
(s1: va_state)
(k: (va_state -> a -> Type0))
: Type0 =
| valid_cmp b s1 /\
(let s1' = va_upd_flags havoc_flags s1 in
(eval_cmp s1 b ==>
mods_contains mods (qc g1).mods /\ QProc?.wp (qc g1) s1' (wp_While_inv qc mods inv dec s1 g1)) /\
(not (eval_cmp s1 b) ==> k s1' g1)) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_While | val wp_While
(#a #d: Type)
(#c: code)
(b: cmp)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g0: a)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | val wp_While
(#a #d: Type)
(#c: code)
(b: cmp)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g0: a)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 | let wp_While
(#a #d:Type) (#c:code) (b:cmp) (qc:a -> quickCode a c) (mods:mods_t) (inv:va_state -> a -> Type0)
(dec:va_state -> a -> d) (g0:a) (s0:va_state) (k:va_state -> a -> Type0)
: Type0 =
inv s0 g0 /\ mods_contains mods (qc g0).mods /\ mods_contains1 mods Mod_flags /\
// REVIEW: we could get a bet... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 86,
"end_line": 287,
"start_col": 0,
"start_line": 281
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Vale.X64.QuickCodes.cmp ->
qc: (_: a -> Vale.X64.QuickCode.quickCode a c) ->
mods: Vale.X64.QuickCode.mods_t ->
inv: (_: Vale.X64.Decls.va_state -> _: a -> Type0) ->
dec: (_: Vale.X64.Decls.va_state -> _: a -> d) ->
g0: a ->
s0: Vale.X64.Decls.va_state ->
k: (_: Vale.X64.Decls.va_sta... | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCodes.cmp",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.QuickCodes.mods_contains",
"Vale.X64.QuickCode.__proj__QProc__item__mods",
"Vale.X64.QuickCodes.mods_contains1",
"V... | [] | false | false | false | false | true | let wp_While
(#a #d: Type)
(#c: code)
(b: cmp)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g0: a)
(s0: va_state)
(k: (va_state -> a -> Type0))
: Type0 =
| inv s0 g0 /\ mods_contains mods (qc g0).mods /\ mods_contains1 mods Mod_flags /\
(forall (s1: va_state) (g1: a). inv s1 g1 ==> wp_While_body b qc mods inv dec g1 s1 k) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.block | val block : block: Vale.X64.Decls.va_codes -> Vale.X64.Decls.va_code | let block = va_Block | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 168,
"start_col": 7,
"start_line": 168
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | block: Vale.X64.Decls.va_codes -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_Block"
] | [] | false | false | false | true | false | let block =
| va_Block | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qAssume | val va_qAssume (#a: Type) (#cs: codes) (r: range) (msg: string) (e: Type0) (qcs: quickCodes a cs)
: quickCodes a cs | val va_qAssume (#a: Type) (#cs: codes) (r: range) (msg: string) (e: Type0) (qcs: quickCodes a cs)
: quickCodes a cs | let va_qAssume (#a:Type) (#cs:codes) (r:range) (msg:string) (e:Type0) (qcs:quickCodes a cs) : quickCodes a cs =
QLemma r msg True (fun () -> e) (qAssumeLemma e) qcs | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 320,
"start_col": 0,
"start_line": 319
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Range.range -> msg: Prims.string -> e: Type0 -> qcs: Vale.X64.QuickCodes.quickCodes a cs
-> Vale.X64.QuickCodes.quickCodes a cs | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"FStar.Range.range",
"Prims.string",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCodes.QLemma",
"Prims.l_True",
"Prims.unit",
"Vale.X64.QuickCodes.qAssumeLemma"
] | [] | false | false | false | false | false | let va_qAssume (#a: Type) (#cs: codes) (r: range) (msg: string) (e: Type0) (qcs: quickCodes a cs)
: quickCodes a cs =
| QLemma r msg True (fun () -> e) (qAssumeLemma e) qcs | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_While_inv | val wp_While_inv
(#a #d: Type)
(#c: code)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(s1: va_state)
(g1: a)
(s2: va_state)
(g2: a)
: Type0 | val wp_While_inv
(#a #d: Type)
(#c: code)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(s1: va_state)
(g1: a)
(s2: va_state)
(g2: a)
: Type0 | let wp_While_inv
(#a #d:Type) (#c:code) (qc:a -> quickCode a c) (mods:mods_t) (inv:va_state -> a -> Type0)
(dec:va_state -> a -> d) (s1:va_state) (g1:a) (s2:va_state) (g2:a)
: Type0 =
s2.vs_ok /\ inv s2 g2 /\ mods_contains mods (qc g2).mods /\ dec s2 g2 << dec s1 g1 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 268,
"start_col": 0,
"start_line": 264
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
qc: (_: a -> Vale.X64.QuickCode.quickCode a c) ->
mods: Vale.X64.QuickCode.mods_t ->
inv: (_: Vale.X64.Decls.va_state -> _: a -> Type0) ->
dec: (_: Vale.X64.Decls.va_state -> _: a -> d) ->
s1: Vale.X64.Decls.va_state ->
g1: a ->
s2: Vale.X64.Decls.va_state ->
g2: a
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.QuickCodes.mods_contains",
"Vale.X64.QuickCode.__proj__QProc__item__mods",
"Prims.precedes"
... | [] | false | false | false | false | true | let wp_While_inv
(#a #d: Type)
(#c: code)
(qc: (a -> quickCode a c))
(mods: mods_t)
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(s1: va_state)
(g1: a)
(s2: va_state)
(g2: a)
: Type0 =
| s2.vs_ok /\ inv s2 g2 /\ mods_contains mods (qc g2).mods /\ dec s2 g2 << dec s1 g1 | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.mods_contains1 | val mods_contains1 (allowed: mods_t) (found: mod_t) : bool | val mods_contains1 (allowed: mods_t) (found: mod_t) : bool | let rec mods_contains1 (allowed:mods_t) (found:mod_t) : bool =
match allowed with
| [] -> mod_eq Mod_None found
| h::t -> mod_eq h found || mods_contains1 t found | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 41,
"start_col": 0,
"start_line": 38
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | allowed: Vale.X64.QuickCode.mods_t -> found: Vale.X64.QuickCode.mod_t -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.mods_t",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.mod_eq",
"Vale.X64.QuickCode.Mod_None",
"Prims.list",
"Prims.op_BarBar",
"Vale.X64.QuickCodes.mods_contains1",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec mods_contains1 (allowed: mods_t) (found: mod_t) : bool =
| match allowed with
| [] -> mod_eq Mod_None found
| h :: t -> mod_eq h found || mods_contains1 t found | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.tAssumeLemma | val tAssumeLemma : p: Type0 -> Type0 | let tAssumeLemma (p:Type0) = unit -> Lemma (requires True) (ensures p) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 315,
"start_col": 0,
"start_line": 315
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | false | true | true | let tAssumeLemma (p: Type0) =
| unit -> Lemma (requires True) (ensures p) | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qAssertSquash | val va_qAssertSquash
(#a: Type)
(#cs: codes)
(r: range)
(msg: string)
(e: Type0)
(qcs: (squash e -> GTot (quickCodes a cs)))
: quickCodes a ((Block []) :: cs) | val va_qAssertSquash
(#a: Type)
(#cs: codes)
(r: range)
(msg: string)
(e: Type0)
(qcs: (squash e -> GTot (quickCodes a cs)))
: quickCodes a ((Block []) :: cs) | let va_qAssertSquash
(#a:Type) (#cs:codes) (r:range) (msg:string) (e:Type0) (qcs:squash e -> GTot (quickCodes a cs))
: quickCodes a ((Block [])::cs) =
QGhost (squash e) r msg e (fun () -> e) (qAssertSquashLemma e) qcs | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 329,
"start_col": 0,
"start_line": 326
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.Range.range ->
msg: Prims.string ->
e: Type0 ->
qcs: (_: Prims.squash e -> Prims.GTot (Vale.X64.QuickCodes.quickCodes a cs))
-> Vale.X64.QuickCodes.quickCodes a (Vale.X64.Machine_s.Block [] :: cs) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"FStar.Range.range",
"Prims.string",
"Prims.squash",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCodes.QGhost",
"Prims.unit",
"Vale.X64.QuickCodes.qAssertSquashLemma",
"Prims.Cons",
"Vale.X64.Decls.va_code",
"Vale.X64.Machine_s.Block",
"Vale.X64.Decls.ins",
... | [] | false | false | false | false | false | let va_qAssertSquash
(#a: Type)
(#cs: codes)
(r: range)
(msg: string)
(e: Type0)
(qcs: (squash e -> GTot (quickCodes a cs)))
: quickCodes a ((Block []) :: cs) =
| QGhost (squash e) r msg e (fun () -> e) (qAssertSquashLemma e) qcs | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.mods_contains | val mods_contains (allowed found: mods_t) : bool | val mods_contains (allowed found: mods_t) : bool | let rec mods_contains (allowed:mods_t) (found:mods_t) : bool =
match found with
| [] -> true
| h::t -> mods_contains1 allowed h && mods_contains allowed t | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 47,
"start_col": 0,
"start_line": 44
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | allowed: Vale.X64.QuickCode.mods_t -> found: Vale.X64.QuickCode.mods_t -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.mods_t",
"Vale.X64.QuickCode.mod_t",
"Prims.list",
"Prims.op_AmpAmp",
"Vale.X64.QuickCodes.mods_contains1",
"Vale.X64.QuickCodes.mods_contains",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec mods_contains (allowed found: mods_t) : bool =
| match found with
| [] -> true
| h :: t -> mods_contains1 allowed h && mods_contains allowed t | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.tAssertLemma | val tAssertLemma : p: Type0 -> Type0 | let tAssertLemma (p:Type0) = unit -> Lemma (requires p) (ensures p) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 308,
"start_col": 0,
"start_line": 308
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | false | true | true | let tAssertLemma (p: Type0) =
| unit -> Lemma (requires p) (ensures p) | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qAssert | val va_qAssert (#a: Type) (#cs: codes) (r: range) (msg: string) (e: Type0) (qcs: quickCodes a cs)
: quickCodes a cs | val va_qAssert (#a: Type) (#cs: codes) (r: range) (msg: string) (e: Type0) (qcs: quickCodes a cs)
: quickCodes a cs | let va_qAssert (#a:Type) (#cs:codes) (r:range) (msg:string) (e:Type0) (qcs:quickCodes a cs) : quickCodes a cs =
QLemma r msg e (fun () -> e) (qAssertLemma e) qcs | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 313,
"start_col": 0,
"start_line": 312
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Range.range -> msg: Prims.string -> e: Type0 -> qcs: Vale.X64.QuickCodes.quickCodes a cs
-> Vale.X64.QuickCodes.quickCodes a cs | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"FStar.Range.range",
"Prims.string",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCodes.QLemma",
"Prims.unit",
"Vale.X64.QuickCodes.qAssertLemma"
] | [] | false | false | false | false | false | let va_qAssert (#a: Type) (#cs: codes) (r: range) (msg: string) (e: Type0) (qcs: quickCodes a cs)
: quickCodes a cs =
| QLemma r msg e (fun () -> e) (qAssertLemma e) qcs | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.label | val label (r: range) (msg: string) (p: Type0)
: Ghost Type (requires True) (ensures fun q -> q <==> p) | val label (r: range) (msg: string) (p: Type0)
: Ghost Type (requires True) (ensures fun q -> q <==> p) | let label (r:range) (msg:string) (p:Type0) : Ghost Type (requires True) (ensures fun q -> q <==> p) =
assert_norm (labeled_wrap r msg p <==> p);
labeled_wrap r msg p | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 27,
"start_col": 0,
"start_line": 25
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Range.range -> msg: Prims.string -> p: Type0 -> Prims.Ghost Type0 | Prims.Ghost | [] | [] | [
"FStar.Range.range",
"Prims.string",
"Vale.X64.QuickCodes.labeled_wrap",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.l_iff",
"Prims.l_True"
] | [] | false | false | false | false | true | let label (r: range) (msg: string) (p: Type0)
: Ghost Type (requires True) (ensures fun q -> q <==> p) =
| assert_norm (labeled_wrap r msg p <==> p);
labeled_wrap r msg p | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.state_match | val state_match (s0 s1: va_state) : Type0 | val state_match (s0 s1: va_state) : Type0 | let state_match (s0:va_state) (s1:va_state) : Type0 =
s0.vs_ok == s1.vs_ok /\
all_regs_match s0.vs_regs s1.vs_regs /\
s0.vs_flags == s1.vs_flags /\
s0.vs_heap == s1.vs_heap /\
s0.vs_stack == s1.vs_stack /\
s0.vs_stackTaint == s1.vs_stackTaint | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 373,
"start_col": 0,
"start_line": 367
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s0: Vale.X64.Decls.va_state -> s1: Vale.X64.Decls.va_state -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.QuickCodes.all_regs_match",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.Flags.t",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.... | [] | false | false | false | true | true | let state_match (s0 s1: va_state) : Type0 =
| s0.vs_ok == s1.vs_ok /\ all_regs_match s0.vs_regs s1.vs_regs /\ s0.vs_flags == s1.vs_flags /\
s0.vs_heap == s1.vs_heap /\ s0.vs_stack == s1.vs_stack /\ s0.vs_stackTaint == s1.vs_stackTaint | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.normal_steps | val normal_steps:list string | val normal_steps:list string | let normal_steps : list string =
[
`%Mkvale_state?.vs_ok;
`%Mkvale_state?.vs_regs;
`%Mkvale_state?.vs_flags;
`%Mkvale_state?.vs_heap;
`%Mkvale_state?.vs_stack;
`%Mkvale_state?.vs_stackTaint;
`%Mkvale_full_heap?.vf_layout;
`%Mkvale_full_heap?.vf_heap;
`%Mkvale_full_heap?.vf_heaplets... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 439,
"start_col": 7,
"start_line": 421
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.list Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Prims.string",
"Prims.Nil"
] | [] | false | false | false | true | false | let normal_steps:list string =
| [
`%Mkvale_state?.vs_ok; `%Mkvale_state?.vs_regs; `%Mkvale_state?.vs_flags; `%Mkvale_state?.vs_heap;
`%Mkvale_state?.vs_stack; `%Mkvale_state?.vs_stackTaint; `%Mkvale_full_heap?.vf_layout;
`%Mkvale_full_heap?.vf_heap; `%Mkvale_full_heap?.vf_heaplets; `%QProc?.wp; `%QProc?.mods;
`%OConst?; `%OReg?; `%OMem?; `%OS... | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qAssertBy | val va_qAssertBy
(#a: Type)
(#cs: codes)
(r: range)
(msg: string)
(p: Type0)
(qcsBy: quickCodes unit [])
(qcsTail: quickCodes a cs)
: quickCodes a cs | val va_qAssertBy
(#a: Type)
(#cs: codes)
(r: range)
(msg: string)
(p: Type0)
(qcsBy: quickCodes unit [])
(qcsTail: quickCodes a cs)
: quickCodes a cs | let va_qAssertBy (#a:Type) (#cs:codes) (r:range) (msg:string) (p:Type0) (qcsBy:quickCodes unit []) (qcsTail:quickCodes a cs) : quickCodes a cs =
QAssertBy r msg p qcsBy qcsTail | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 341,
"start_col": 0,
"start_line": 340
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.Range.range ->
msg: Prims.string ->
p: Type0 ->
qcsBy: Vale.X64.QuickCodes.quickCodes Prims.unit [] ->
qcsTail: Vale.X64.QuickCodes.quickCodes a cs
-> Vale.X64.QuickCodes.quickCodes a cs | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"FStar.Range.range",
"Prims.string",
"Vale.X64.QuickCodes.quickCodes",
"Prims.unit",
"Prims.Nil",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.QuickCodes.QAssertBy"
] | [] | false | false | false | false | false | let va_qAssertBy
(#a: Type)
(#cs: codes)
(r: range)
(msg: string)
(p: Type0)
(qcsBy: quickCodes unit [])
(qcsTail: quickCodes a cs)
: quickCodes a cs =
| QAssertBy r msg p qcsBy qcsTail | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.tAssertSquashLemma | val tAssertSquashLemma : p: Type0 -> Type0 | let tAssertSquashLemma (p:Type0) = unit -> Ghost (squash p) (requires p) (ensures fun () -> p) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 322,
"start_col": 0,
"start_line": 322
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.squash"
] | [] | false | false | false | true | true | let tAssertSquashLemma (p: Type0) =
| unit -> Ghost (squash p) (requires p) (ensures fun () -> p) | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_sound_code_post | val wp_sound_code_post : qc: Vale.X64.QuickCode.quickCode a c ->
s0: Vale.X64.Decls.va_state ->
k: (s0': Vale.X64.Decls.va_state{s0 == s0'} -> _: Vale.X64.Decls.va_state -> _: a -> Type0) ->
_: ((Vale.X64.State.vale_state * Vale.X64.Decls.va_fuel) * a)
-> Type0 | let wp_sound_code_post (#a:Type0) (#c:code) (qc:quickCode a c) (s0:va_state) (k:(s0':va_state{s0 == s0'}) -> va_state -> a -> Type0) ((sN:va_state), (fN:fuel), (gN:a)) : Type0 =
eval c s0 fN sN /\
update_state_mods qc.mods sN s0 == sN /\
state_inv sN /\
k s0 sN gN | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 419,
"start_col": 7,
"start_line": 415
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
qc: Vale.X64.QuickCode.quickCode a c ->
s0: Vale.X64.Decls.va_state ->
k: (s0': Vale.X64.Decls.va_state{s0 == s0'} -> _: Vale.X64.Decls.va_state -> _: a -> Type0) ->
_: ((Vale.X64.State.vale_state * Vale.X64.Decls.va_fuel) * a)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.Decls.va_state",
"Prims.eq2",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.X64.QuickCodes.eval",
"Vale.X64.QuickCode.update_state_mods",
"Vale.X64.QuickCode.__pr... | [] | false | false | false | false | true | let wp_sound_code_post
(#a: Type0)
(#c: code)
(qc: quickCode a c)
(s0: va_state)
(k: (s0': va_state{s0 == s0'} -> va_state -> a -> Type0))
((sN: va_state), (fN: fuel), (gN: a))
: Type0 =
| eval c s0 fN sN /\ update_state_mods qc.mods sN s0 == sN /\ state_inv sN /\ k s0 sN gN | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.normal | val normal (x: Type0) : Type0 | val normal (x: Type0) : Type0 | let normal (x:Type0) : Type0 = norm [nbe; iota; zeta; simplify; primops; delta_attr [`%va_qattr]; delta_only normal_steps] x | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 131,
"end_line": 441,
"start_col": 7,
"start_line": 441
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.nbe",
"FStar.Pervasives.iota",
"FStar.Pervasives.zeta",
"FStar.Pervasives.simplify",
"FStar.Pervasives.primops",
"FStar.Pervasives.delta_attr",
"Prims.string",
"Prims.Nil",
"FStar.Pervasives.delta_only",
"... | [] | false | false | false | true | true | let normal (x: Type0) : Type0 =
| norm [nbe; iota; zeta; simplify; primops; delta_attr [`%va_qattr]; delta_only normal_steps] x | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qPURE | val va_qPURE
(#cs: codes)
(#pre: ((unit -> GTot Type0) -> GTot Type0){is_monotonic pre})
(#a: Type0)
(r: range)
(msg: string)
($l:
(unit
-> PURE unit
(intro_pure_wp_monotonicity pre;
pre)))
(qcs: quickCodes a cs)
... | val va_qPURE
(#cs: codes)
(#pre: ((unit -> GTot Type0) -> GTot Type0){is_monotonic pre})
(#a: Type0)
(r: range)
(msg: string)
($l:
(unit
-> PURE unit
(intro_pure_wp_monotonicity pre;
pre)))
(qcs: quickCodes a cs)
... | let va_qPURE
(#cs:codes) (#pre:((unit -> GTot Type0) -> GTot Type0){is_monotonic pre}) (#a:Type0) (r:range) (msg:string)
($l:unit -> PURE unit (intro_pure_wp_monotonicity pre; pre)) (qcs:quickCodes a cs)
: quickCodes a cs =
QPURE r msg pre l qcs | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 82,
"start_col": 0,
"start_line": 78
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.Range.range ->
msg: Prims.string ->
$l: (_: Prims.unit -> Prims.PURE Prims.unit) ->
qcs: Vale.X64.QuickCodes.quickCodes a cs
-> Vale.X64.QuickCodes.quickCodes a cs | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"Prims.unit",
"FStar.Monotonic.Pure.is_monotonic",
"FStar.Range.range",
"Prims.string",
"FStar.Monotonic.Pure.intro_pure_wp_monotonicity",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCodes.QPURE"
] | [] | false | false | false | false | false | let va_qPURE
(#cs: codes)
(#pre: ((unit -> GTot Type0) -> GTot Type0){is_monotonic pre})
(#a: Type0)
(r: range)
(msg: string)
($l:
(unit
-> PURE unit
(intro_pure_wp_monotonicity pre;
pre)))
(qcs: quickCodes a cs)
... | QPURE r msg pre l qcs | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_QLemma | val va_QLemma
(#a: Type0)
(#cs: codes)
(r: range)
(msg: string)
(pre: Type0)
(post: (squash pre -> Type0))
(l: (unit -> Lemma (requires pre) (ensures post ())))
(qcs: quickCodes a cs)
: quickCodes a cs | val va_QLemma
(#a: Type0)
(#cs: codes)
(r: range)
(msg: string)
(pre: Type0)
(post: (squash pre -> Type0))
(l: (unit -> Lemma (requires pre) (ensures post ())))
(qcs: quickCodes a cs)
: quickCodes a cs | let va_QLemma (#a:Type0) (#cs:codes) (r:range) (msg:string) (pre:Type0) (post:(squash pre -> Type0)) (l:unit -> Lemma (requires pre) (ensures post ())) (qcs:quickCodes a cs) : quickCodes a cs = QLemma r msg pre post l qcs | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 240,
"end_line": 74,
"start_col": 19,
"start_line": 74
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.Range.range ->
msg: Prims.string ->
pre: Type0 ->
post: (_: Prims.squash pre -> Type0) ->
l: (_: Prims.unit -> FStar.Pervasives.Lemma (requires pre) (ensures post ())) ->
qcs: Vale.X64.QuickCodes.quickCodes a cs
-> Vale.X64.QuickCodes.quickCodes a cs | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"FStar.Range.range",
"Prims.string",
"Prims.squash",
"Prims.unit",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCodes.QLemma"
] | [] | false | false | false | false | false | let va_QLemma
(#a: Type0)
(#cs: codes)
(r: range)
(msg: string)
(pre: Type0)
(post: (squash pre -> Type0))
(l: (unit -> Lemma (requires pre) (ensures post ())))
(qcs: quickCodes a cs)
: quickCodes a cs =
| QLemma r msg pre post l qcs | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.qblock | val qblock (#a: Type) (#cs: codes) (mods: mods_t) (qcs: (va_state -> GTot (quickCodes a cs)))
: quickCode a (block cs) | val qblock (#a: Type) (#cs: codes) (mods: mods_t) (qcs: (va_state -> GTot (quickCodes a cs)))
: quickCode a (block cs) | let qblock (#a:Type) (#cs:codes) (mods:mods_t) (qcs:va_state -> GTot (quickCodes a cs)) : quickCode a (block cs) =
QProc (block cs) mods (wp_block qcs mods) (qblock_proof qcs mods) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 183,
"start_col": 0,
"start_line": 182
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mods: Vale.X64.QuickCode.mods_t ->
qcs: (_: Vale.X64.Decls.va_state -> Prims.GTot (Vale.X64.QuickCodes.quickCodes a cs))
-> Vale.X64.QuickCode.quickCode a (Vale.X64.QuickCodes.block cs) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.codes",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCode.QProc",
"Vale.X64.QuickCodes.block",
"Vale.X64.QuickCodes.wp_block",
"Vale.X64.QuickCodes.qblock_proof",
"Vale.X64.QuickCode.quickCode"
] | [] | false | false | false | false | false | let qblock (#a: Type) (#cs: codes) (mods: mods_t) (qcs: (va_state -> GTot (quickCodes a cs)))
: quickCode a (block cs) =
| QProc (block cs) mods (wp_block qcs mods) (qblock_proof qcs mods) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qInlineIf | val va_qInlineIf
(#a: Type)
(#c1 #c2: code)
(mods: mods_t)
(b: bool)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
: quickCode a (if_code b c1 c2) | val va_qInlineIf
(#a: Type)
(#c1 #c2: code)
(mods: mods_t)
(b: bool)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
: quickCode a (if_code b c1 c2) | let va_qInlineIf (#a:Type) (#c1:code) (#c2:code) (mods:mods_t) (b:bool) (qc1:quickCode a c1) (qc2:quickCode a c2) : quickCode a (if_code b c1 c2) =
QProc (if_code b c1 c2) mods (wp_InlineIf b qc1 qc2 mods) (qInlineIf_proof b qc1 qc2 mods) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 202,
"start_col": 0,
"start_line": 201
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mods: Vale.X64.QuickCode.mods_t ->
b: Prims.bool ->
qc1: Vale.X64.QuickCode.quickCode a c1 ->
qc2: Vale.X64.QuickCode.quickCode a c2
-> Vale.X64.QuickCode.quickCode a (Vale.X64.QuickCodes.if_code b c1 c2) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCode.mods_t",
"Prims.bool",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.QProc",
"Vale.X64.QuickCodes.if_code",
"Vale.X64.QuickCodes.wp_InlineIf",
"Vale.X64.QuickCodes.qInlineIf_proof"
] | [] | false | false | false | false | false | let va_qInlineIf
(#a: Type)
(#c1 #c2: code)
(mods: mods_t)
(b: bool)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
: quickCode a (if_code b c1 c2) =
| QProc (if_code b c1 c2) mods (wp_InlineIf b qc1 qc2 mods) (qInlineIf_proof b qc1 qc2 mods) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qIf | val va_qIf
(#a: Type)
(#c1 #c2: code)
(mods: mods_t)
(b: cmp)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
: quickCode a (IfElse (cmp_to_ocmp b) c1 c2) | val va_qIf
(#a: Type)
(#c1 #c2: code)
(mods: mods_t)
(b: cmp)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
: quickCode a (IfElse (cmp_to_ocmp b) c1 c2) | let va_qIf (#a:Type) (#c1:code) (#c2:code) (mods:mods_t) (b:cmp) (qc1:quickCode a c1) (qc2:quickCode a c2) : quickCode a (IfElse (cmp_to_ocmp b) c1 c2) =
QProc (IfElse (cmp_to_ocmp b) c1 c2) mods (wp_If b qc1 qc2 mods) (qIf_proof b qc1 qc2 mods) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 259,
"start_col": 0,
"start_line": 258
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mods: Vale.X64.QuickCode.mods_t ->
b: Vale.X64.QuickCodes.cmp ->
qc1: Vale.X64.QuickCode.quickCode a c1 ->
qc2: Vale.X64.QuickCode.quickCode a c2
-> Vale.X64.QuickCode.quickCode a
(Vale.X64.Machine_s.IfElse (Vale.X64.QuickCodes.cmp_to_ocmp b) c1 c2) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.QuickCodes.cmp",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.QuickCode.QProc",
"Vale.X64.Machine_s.IfElse",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.QuickCodes.cmp_to_ocmp",
"Vale.X64.QuickCodes.wp_If",
"Vale.X64.Quic... | [] | false | false | false | false | false | let va_qIf
(#a: Type)
(#c1 #c2: code)
(mods: mods_t)
(b: cmp)
(qc1: quickCode a c1)
(qc2: quickCode a c2)
: quickCode a (IfElse (cmp_to_ocmp b) c1 c2) =
| QProc (IfElse (cmp_to_ocmp b) c1 c2) mods (wp_If b qc1 qc2 mods) (qIf_proof b qc1 qc2 mods) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_qWhile | val va_qWhile
(#a #d: Type)
(#c: code)
(mods: mods_t)
(b: cmp)
(qc: (a -> quickCode a c))
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g0: a)
: quickCode a (While (cmp_to_ocmp b) c) | val va_qWhile
(#a #d: Type)
(#c: code)
(mods: mods_t)
(b: cmp)
(qc: (a -> quickCode a c))
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g0: a)
: quickCode a (While (cmp_to_ocmp b) c) | let va_qWhile
(#a #d:Type) (#c:code) (mods:mods_t) (b:cmp) (qc:a -> quickCode a c) (inv:va_state -> a -> Type0)
(dec:va_state -> a -> d) (g0:a)
: quickCode a (While (cmp_to_ocmp b) c) =
QProc (While (cmp_to_ocmp b) c) mods (wp_While b qc mods inv dec g0)
(qWhile_proof b qc mods inv dec g0) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 304,
"start_col": 0,
"start_line": 299
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mods: Vale.X64.QuickCode.mods_t ->
b: Vale.X64.QuickCodes.cmp ->
qc: (_: a -> Vale.X64.QuickCode.quickCode a c) ->
inv: (_: Vale.X64.Decls.va_state -> _: a -> Type0) ->
dec: (_: Vale.X64.Decls.va_state -> _: a -> d) ->
g0: a
-> Vale.X64.QuickCode.quickCode a (Vale.X64.Machine_s.While (Vale.X6... | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.QuickCodes.cmp",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCode.QProc",
"Vale.X64.Machine_s.While",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.QuickCodes.cmp_to_ocmp",
"Vale.X64.QuickCo... | [] | false | false | false | false | false | let va_qWhile
(#a #d: Type)
(#c: code)
(mods: mods_t)
(b: cmp)
(qc: (a -> quickCode a c))
(inv: (va_state -> a -> Type0))
(dec: (va_state -> a -> d))
(g0: a)
: quickCode a (While (cmp_to_ocmp b) c) =
| QProc (While (cmp_to_ocmp b) c)
mods
(wp_While b qc mods inv dec g0)
(qWhile_proof b qc mods inv dec g0) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.eval_cmp | val eval_cmp (s: va_state) (c: cmp) : GTot bool | val eval_cmp (s: va_state) (c: cmp) : GTot bool | let eval_cmp (s:va_state) (c:cmp) : GTot bool =
match c with
| Cmp_eq o1 o2 -> va_eval_opr64 s o1 = va_eval_opr64 s o2
| Cmp_ne o1 o2 -> va_eval_opr64 s o1 <> va_eval_opr64 s o2
| Cmp_le o1 o2 -> va_eval_opr64 s o1 <= va_eval_opr64 s o2
| Cmp_ge o1 o2 -> va_eval_opr64 s o1 >= va_eval_opr64 s o2
| Cmp_lt o1... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 240,
"start_col": 0,
"start_line": 233
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Vale.X64.Decls.va_state -> c: Vale.X64.QuickCodes.cmp -> Prims.GTot Prims.bool | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.cmp",
"Vale.X64.Machine_s.operand64",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_BarBar",
"Vale.X64.Machine_s.uu___is_OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.uu___is_OStack",
"Prims.op_Equality",
"Vale... | [] | false | false | false | false | false | let eval_cmp (s: va_state) (c: cmp) : GTot bool =
| match c with
| Cmp_eq o1 o2 -> va_eval_opr64 s o1 = va_eval_opr64 s o2
| Cmp_ne o1 o2 -> va_eval_opr64 s o1 <> va_eval_opr64 s o2
| Cmp_le o1 o2 -> va_eval_opr64 s o1 <= va_eval_opr64 s o2
| Cmp_ge o1 o2 -> va_eval_opr64 s o1 >= va_eval_opr64 s o2
| Cmp_lt o1 o2 -> va_eval_opr64 s o1 < va_eval_opr64 s o2
| Cmp_gt o1 o2... | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.valid_cmp | val valid_cmp (c: cmp) (s: va_state) : Type0 | val valid_cmp (c: cmp) (s: va_state) : Type0 | let valid_cmp (c:cmp) (s:va_state) : Type0 =
match c with
| Cmp_eq o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_ne o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_le o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_ge o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_lt o1 o2... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 230,
"start_col": 0,
"start_line": 223
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: Vale.X64.QuickCodes.cmp -> s: Vale.X64.Decls.va_state -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.cmp",
"Vale.X64.Decls.va_state",
"Vale.X64.Machine_s.operand64",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_BarBar",
"Vale.X64.Machine_s.uu___is_OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.uu___is_OStack",
"Prims.l_and",
"Vale.X64.D... | [] | false | false | false | true | true | let valid_cmp (c: cmp) (s: va_state) : Type0 =
| match c with
| Cmp_eq o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_ne o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_le o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_ge o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_lt o1 o2 -> valid_operand o1 s /\ valid_operand o2 s
| Cmp_gt o1 ... | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.cmp_to_ocmp | val cmp_to_ocmp (c: cmp) : ocmp | val cmp_to_ocmp (c: cmp) : ocmp | let cmp_to_ocmp (c:cmp) : ocmp =
match c with
| Cmp_eq o1 o2 -> va_cmp_eq o1 o2
| Cmp_ne o1 o2 -> va_cmp_ne o1 o2
| Cmp_le o1 o2 -> va_cmp_le o1 o2
| Cmp_ge o1 o2 -> va_cmp_ge o1 o2
| Cmp_lt o1 o2 -> va_cmp_lt o1 o2
| Cmp_gt o1 o2 -> va_cmp_gt o1 o2 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 220,
"start_col": 0,
"start_line": 213
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: Vale.X64.QuickCodes.cmp -> Vale.X64.Decls.ocmp | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.cmp",
"Vale.X64.Machine_s.operand64",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_BarBar",
"Vale.X64.Machine_s.uu___is_OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.uu___is_OStack",
"Vale.X64.Decls.va_cmp_eq",
"Vale.X64.Decls.va_cmp_ne",... | [] | false | false | false | true | false | let cmp_to_ocmp (c: cmp) : ocmp =
| match c with
| Cmp_eq o1 o2 -> va_cmp_eq o1 o2
| Cmp_ne o1 o2 -> va_cmp_ne o1 o2
| Cmp_le o1 o2 -> va_cmp_le o1 o2
| Cmp_ge o1 o2 -> va_cmp_ge o1 o2
| Cmp_lt o1 o2 -> va_cmp_lt o1 o2
| Cmp_gt o1 o2 -> va_cmp_gt o1 o2 | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_sound_code_pre | val wp_sound_code_pre
(#a: Type0)
(#c: code)
(qc: quickCode a c)
(s0: va_state)
(k: (s0': va_state{s0 == s0'} -> va_state -> a -> Type0))
: Type0 | val wp_sound_code_pre
(#a: Type0)
(#c: code)
(qc: quickCode a c)
(s0: va_state)
(k: (s0': va_state{s0 == s0'} -> va_state -> a -> Type0))
: Type0 | let wp_sound_code_pre (#a:Type0) (#c:code) (qc:quickCode a c) (s0:va_state) (k:(s0':va_state{s0 == s0'}) -> va_state -> a -> Type0) : Type0 =
forall
(ok:bool)
(regs:Regs.t)
(flags:Flags.t)
//(mem:vale_full_heap) // splitting mem into its components makes the VCs slightly cleaner:
(mem_la... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 413,
"start_col": 7,
"start_line": 388
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
qc: Vale.X64.QuickCode.quickCode a c ->
s0: Vale.X64.Decls.va_state ->
k: (s0': Vale.X64.Decls.va_state{s0 == s0'} -> _: Vale.X64.Decls.va_state -> _: a -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCodes.code",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.Decls.va_state",
"Prims.eq2",
"Prims.l_Forall",
"Prims.bool",
"Vale.X64.Regs.t",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.Decls.vale_heap",
"Vale.Arch.HeapImpl.vale_heaplets",
"Vale.X64.Stack_i.va... | [] | false | false | false | false | true | let wp_sound_code_pre
(#a: Type0)
(#c: code)
(qc: quickCode a c)
(s0: va_state)
(k: (s0': va_state{s0 == s0'} -> va_state -> a -> Type0))
: Type0 =
| forall (ok: bool)
(regs: Regs.t)
(flags: Flags.t)
(mem_layout: vale_heap_layout)
(mem_heap: vale_heap)
(mem_heaplets: vale_heaplets)
(stack: vale_stack)
(stackTaint: memtaint).
let mem = { vf_layout = mem_layout; vf_heap = mem_heap; vf_heaplets = mem_heaplets } in
let s0' =
{
vs_ok = ok;
... | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.regs_match | val regs_match (r0 r1: Regs.t) (k: nat{k <= n_reg_files}) : Type0 | val regs_match (r0 r1: Regs.t) (k: nat{k <= n_reg_files}) : Type0 | let rec regs_match (r0:Regs.t) (r1:Regs.t) (k:nat{k <= n_reg_files}) : Type0 =
if k = 0 then True
else regs_match_file r0 r1 (k - 1) (n_regs (k - 1)) /\ regs_match r0 r1 (k - 1) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 360,
"start_col": 0,
"start_line": 358
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r0: Vale.X64.Regs.t -> r1: Vale.X64.Regs.t -> k: Prims.nat{k <= Vale.X64.Machine_s.n_reg_files}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Regs.t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Vale.X64.Machine_s.n_reg_files",
"Prims.op_Equality",
"Prims.int",
"Prims.l_True",
"Prims.bool",
"Prims.l_and",
"Vale.X64.QuickCodes.regs_match_file",
"Prims.op_Subtraction",
"Vale.X64.Machine_s.n_regs",
"Vale.X64.Qu... | [
"recursion"
] | false | false | false | false | true | let rec regs_match (r0 r1: Regs.t) (k: nat{k <= n_reg_files}) : Type0 =
| if k = 0 then True else regs_match_file r0 r1 (k - 1) (n_regs (k - 1)) /\ regs_match r0 r1 (k - 1) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.regs_match_file | val regs_match_file (r0 r1: Regs.t) (rf: reg_file_id) (k: nat{k <= n_regs rf}) : Type0 | val regs_match_file (r0 r1: Regs.t) (rf: reg_file_id) (k: nat{k <= n_regs rf}) : Type0 | let rec regs_match_file (r0:Regs.t) (r1:Regs.t) (rf:reg_file_id) (k:nat{k <= n_regs rf}) : Type0 =
if k = 0 then True
else
let r = Reg rf (k - 1) in
Regs.sel r r0 == Regs.sel r r1 /\ regs_match_file r0 r1 rf (k - 1) | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 355,
"start_col": 0,
"start_line": 351
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r0: Vale.X64.Regs.t ->
r1: Vale.X64.Regs.t ->
rf: Vale.X64.Machine_s.reg_file_id ->
k: Prims.nat{k <= Vale.X64.Machine_s.n_regs rf}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Regs.t",
"Vale.X64.Machine_s.reg_file_id",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Vale.X64.Machine_s.n_regs",
"Prims.op_Equality",
"Prims.int",
"Prims.l_True",
"Prims.bool",
"Prims.l_and",
"Prims.eq2",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Regs.sel",
"Vale.X64.Q... | [
"recursion"
] | false | false | false | false | true | let rec regs_match_file (r0 r1: Regs.t) (rf: reg_file_id) (k: nat{k <= n_regs rf}) : Type0 =
| if k = 0
then True
else
let r = Reg rf (k - 1) in
Regs.sel r r0 == Regs.sel r r1 /\ regs_match_file r0 r1 rf (k - 1) | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_Seq | val wp_Seq
(#a #b: Type0)
(cs: codes)
(qcs: quickCodes b cs)
(mods: mods_t)
(k: (va_state -> b -> Type0))
: Tot (wp_Seq_t a) (decreases %[cs;1;qcs]) | val wp_Seq
(#a #b: Type0)
(cs: codes)
(qcs: quickCodes b cs)
(mods: mods_t)
(k: (va_state -> b -> Type0))
: Tot (wp_Seq_t a) (decreases %[cs;1;qcs]) | let rec wp (#a:Type0) (cs:codes) (qcs:quickCodes a cs) (mods:mods_t) (k:va_state -> a -> Type0) (s0:va_state) :
Tot Type0 (decreases %[cs; 0; qcs])
=
match qcs with
| QEmpty g -> k s0 g
| QSeq r msg qc qcs ->
let c::cs = cs in
label r msg (mods_contains mods qc.mods /\ wp_proc c qc s0 (wp_Seq cs q... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 157,
"start_col": 0,
"start_line": 110
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
cs: Vale.X64.QuickCodes.codes ->
qcs: Vale.X64.QuickCodes.quickCodes b cs ->
mods: Vale.X64.QuickCode.mods_t ->
k: (_: Vale.X64.Decls.va_state -> _: b -> Type0)
-> Prims.Tot (Vale.X64.QuickCodes.wp_Seq_t a) | Prims.Tot | [
"total",
""
] | [
"wp",
"wp_Seq",
"wp_Bind"
] | [
"Vale.X64.QuickCodes.codes",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Vale.X64.State.vale_state",
"Prims.l_or",
"Prims.precedes",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Prims.l_and",
"Prims.o... | [
"mutual recursion"
] | false | false | false | false | false | let rec wp_Seq
(#a #b: Type0)
(cs: codes)
(qcs: quickCodes b cs)
(mods: mods_t)
(k: (va_state -> b -> Type0))
: Tot (wp_Seq_t a) (decreases %[cs;1;qcs]) =
| let f s0 _ = wp cs qcs mods k s0 in
f | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.all_regs_match | val all_regs_match (r0 r1: Regs.t) : Type0 | val all_regs_match (r0 r1: Regs.t) : Type0 | let all_regs_match (r0:Regs.t) (r1:Regs.t) : Type0 =
regs_match r0 r1 n_reg_files | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 364,
"start_col": 0,
"start_line": 363
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r0: Vale.X64.Regs.t -> r1: Vale.X64.Regs.t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Regs.t",
"Vale.X64.QuickCodes.regs_match",
"Vale.X64.Machine_s.n_reg_files"
] | [] | false | false | false | true | true | let all_regs_match (r0 r1: Regs.t) : Type0 =
| regs_match r0 r1 n_reg_files | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.uint64 | val uint64 : Prims.eqtype | let uint64 = UInt64.t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 27,
"start_col": 0,
"start_line": 27
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt64.t"
] | [] | false | false | false | true | false | let uint64 =
| UInt64.t | false | |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp_Bind | val wp_Bind
(#a #b: Type0)
(cs: codes)
(qcs: (va_state -> a -> GTot (quickCodes b cs)))
(mods: mods_t)
(k: (va_state -> b -> Type0))
: Tot (wp_Bind_t a) (decreases %[cs;1;qcs]) | val wp_Bind
(#a #b: Type0)
(cs: codes)
(qcs: (va_state -> a -> GTot (quickCodes b cs)))
(mods: mods_t)
(k: (va_state -> b -> Type0))
: Tot (wp_Bind_t a) (decreases %[cs;1;qcs]) | let rec wp (#a:Type0) (cs:codes) (qcs:quickCodes a cs) (mods:mods_t) (k:va_state -> a -> Type0) (s0:va_state) :
Tot Type0 (decreases %[cs; 0; qcs])
=
match qcs with
| QEmpty g -> k s0 g
| QSeq r msg qc qcs ->
let c::cs = cs in
label r msg (mods_contains mods qc.mods /\ wp_proc c qc s0 (wp_Seq cs q... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 157,
"start_col": 0,
"start_line": 110
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
cs: Vale.X64.QuickCodes.codes ->
qcs: (_: Vale.X64.Decls.va_state -> _: a -> Prims.GTot (Vale.X64.QuickCodes.quickCodes b cs)) ->
mods: Vale.X64.QuickCode.mods_t ->
k: (_: Vale.X64.Decls.va_state -> _: b -> Type0)
-> Prims.Tot (Vale.X64.QuickCodes.wp_Bind_t a) | Prims.Tot | [
"total",
""
] | [
"wp",
"wp_Seq",
"wp_Bind"
] | [
"Vale.X64.QuickCodes.codes",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.State.vale_state",
"Vale.X64.QuickCodes.wp",
"Vale.X64.QuickCodes.wp_Bind_t"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec wp_Bind
(#a #b: Type0)
(cs: codes)
(qcs: (va_state -> a -> GTot (quickCodes b cs)))
(mods: mods_t)
(k: (va_state -> b -> Type0))
: Tot (wp_Bind_t a) (decreases %[cs;1;qcs]) =
| let f s0 g = wp cs (qcs s0 g) mods k s0 in
f | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.wp | val wp
(#a: Type0)
(cs: codes)
(qcs: quickCodes a cs)
(mods: mods_t)
(k: (va_state -> a -> Type0))
(s0: va_state)
: Tot Type0 (decreases %[cs;0;qcs]) | val wp
(#a: Type0)
(cs: codes)
(qcs: quickCodes a cs)
(mods: mods_t)
(k: (va_state -> a -> Type0))
(s0: va_state)
: Tot Type0 (decreases %[cs;0;qcs]) | let rec wp (#a:Type0) (cs:codes) (qcs:quickCodes a cs) (mods:mods_t) (k:va_state -> a -> Type0) (s0:va_state) :
Tot Type0 (decreases %[cs; 0; qcs])
=
match qcs with
| QEmpty g -> k s0 g
| QSeq r msg qc qcs ->
let c::cs = cs in
label r msg (mods_contains mods qc.mods /\ wp_proc c qc s0 (wp_Seq cs q... | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 157,
"start_col": 0,
"start_line": 110
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
cs: Vale.X64.QuickCodes.codes ->
qcs: Vale.X64.QuickCodes.quickCodes a cs ->
mods: Vale.X64.QuickCode.mods_t ->
k: (_: Vale.X64.Decls.va_state -> _: a -> Type0) ->
s0: Vale.X64.Decls.va_state
-> Prims.Tot Type0 | Prims.Tot | [
"total",
""
] | [
"wp",
"wp_Seq",
"wp_Bind"
] | [
"Vale.X64.QuickCodes.codes",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCode.mods_t",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.code",
"FStar.Range.range",
"Prims.string",
"Vale.X64.QuickCode.quickCode",
"Vale.X64.Decls.va_code",
"Prims.list",
"Vale.X64.QuickCodes.label",
"Prims.l_... | [
"mutual recursion"
] | false | false | false | false | true | let rec wp
(#a: Type0)
(cs: codes)
(qcs: quickCodes a cs)
(mods: mods_t)
(k: (va_state -> a -> Type0))
(s0: va_state)
: Tot Type0 (decreases %[cs;0;qcs]) =
| match qcs with
| QEmpty g -> k s0 g
| QSeq r msg qc qcs ->
let c :: cs = cs in
label r msg (mods_contains mods qc.mods /\ wp_proc c qc s0 (wp_Seq cs qcs mods k))
| QBind r msg qc qcs ->
let c :: cs = cs in
label r msg (mods_contains mods qc.mods /\ wp_proc c qc s0 (wp_Bind cs qcs mods k))
| QGetState f ->
let... | false |
Vale.X64.QuickCodes.fsti | Vale.X64.QuickCodes.va_state_match | val va_state_match (s0 s1: va_state)
: Pure Type0 (requires True) (ensures fun b -> b ==> state_eq s0 s1) | val va_state_match (s0 s1: va_state)
: Pure Type0 (requires True) (ensures fun b -> b ==> state_eq s0 s1) | let va_state_match (s0:va_state) (s1:va_state) : Pure Type0
(requires True)
(ensures fun b -> b ==> state_eq s0 s1)
=
FStar.Classical.move_requires (lemma_state_match s0) s1;
state_match s0 s1 | {
"file_name": "vale/code/arch/x64/Vale.X64.QuickCodes.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 385,
"start_col": 0,
"start_line": 380
} | module Vale.X64.QuickCodes
// Optimized weakest precondition generation for 'quick' procedures
open FStar.Mul
open FStar.Range
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
unfold let code ... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fs... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "FStar.Range",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s0: Vale.X64.Decls.va_state -> s1: Vale.X64.Decls.va_state -> Prims.Pure Type0 | Prims.Pure | [] | [] | [
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.state_match",
"Prims.unit",
"FStar.Classical.move_requires",
"Vale.X64.State.state_eq",
"Vale.X64.QuickCodes.lemma_state_match",
"Prims.l_True",
"Prims.l_imp"
] | [] | false | false | false | false | true | let va_state_match (s0 s1: va_state)
: Pure Type0 (requires True) (ensures fun b -> b ==> state_eq s0 s1) =
| FStar.Classical.move_requires (lemma_state_match s0) s1;
state_match s0 s1 | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.b128 | val b128 : Type0 | let b128 = buf_t TUInt8 TUInt128 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.buf_t",
"Vale.Arch.HeapTypes_s.TUInt8",
"Vale.Arch.HeapTypes_s.TUInt128"
] | [] | false | false | false | true | true | let b128 =
| buf_t TUInt8 TUInt128 | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.tuint64 | val tuint64 : Vale.Interop.Base.td | let tuint64 = TD_Base TUInt64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 42,
"start_col": 0,
"start_line": 42
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.Interop.Base.td | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.TD_Base",
"Vale.Arch.HeapTypes_s.TUInt64"
] | [] | false | false | false | true | false | let tuint64 =
| TD_Base TUInt64 | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.t128_no_mod | val t128_no_mod : Vale.Interop.Base.td | let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret}) | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 106,
"end_line": 40,
"start_col": 0,
"start_line": 40
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.Interop.Base.td | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.TD_Buffer",
"Vale.Arch.HeapTypes_s.TUInt8",
"Vale.Arch.HeapTypes_s.TUInt128",
"Vale.Interop.Base.Mkbuffer_qualifiers",
"Vale.Arch.HeapTypes_s.Secret"
] | [] | false | false | false | true | false | let t128_no_mod =
| TD_Buffer TUInt8 TUInt128 ({ modified = false; strict_disjointness = false; taint = MS.Secret }) | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.t128_mod | val t128_mod : Vale.Interop.Base.td | let t128_mod = TD_Buffer TUInt8 TUInt128 default_bq | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 38,
"start_col": 0,
"start_line": 38
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.Interop.Base.td | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.TD_Buffer",
"Vale.Arch.HeapTypes_s.TUInt8",
"Vale.Arch.HeapTypes_s.TUInt128",
"Vale.Interop.Base.default_bq"
] | [] | false | false | false | true | false | let t128_mod =
| TD_Buffer TUInt8 TUInt128 default_bq | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.code_gctr128 | val code_gctr128 : Vale.X64.Decls.va_code | let code_gctr128 = GC.va_code_Gctr_bytes_stdcall IA.win AES_128 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 131,
"start_col": 0,
"start_line": 131
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.X64.GCTR.va_code_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_128"
] | [] | false | false | false | true | false | let code_gctr128 =
| GC.va_code_Gctr_bytes_stdcall IA.win AES_128 | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.code_gctr256 | val code_gctr256 : Vale.X64.Decls.va_code | let code_gctr256 = GC.va_code_Gctr_bytes_stdcall IA.win AES_256 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 234,
"start_col": 0,
"start_line": 234
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.X64.GCTR.va_code_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_256"
] | [] | false | false | false | true | false | let code_gctr256 =
| GC.va_code_Gctr_bytes_stdcall IA.win AES_256 | false | |
FStar.BigOps.fst | FStar.BigOps.big_and'_nil | val big_and'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_and' f [] == True) | val big_and'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_and' f [] == True) | let big_and'_nil (#a:Type) (f:a -> Type)
= assert (big_and' f [] == True) by (T.compute()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 35,
"start_col": 0,
"start_line": 34
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> FStar.Pervasives.Lemma (ensures FStar.BigOps.big_and' f [] == Prims.l_True) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.big_and'",
"Prims.Nil",
"Prims.l_True",
"Prims.unit",
"FStar.Tactics.V2.Derived.compute"
] | [] | false | false | true | false | false | let big_and'_nil (#a: Type) (f: (a -> Type)) =
| FStar.Tactics.Effect.assert_by_tactic (big_and' f [] == True)
(fun _ ->
();
(T.compute ())) | false |
FStar.BigOps.fst | FStar.BigOps.big_or'_nil | val big_or'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_or' f [] == False) | val big_or'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_or' f [] == False) | let big_or'_nil (#a:Type) (f:a -> Type)
= assert (big_or' f [] == False) by (T.compute()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 52,
"start_col": 0,
"start_line": 51
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> FStar.Pervasives.Lemma (ensures FStar.BigOps.big_or' f [] == Prims.l_False) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.big_or'",
"Prims.Nil",
"Prims.l_False",
"Prims.unit",
"FStar.Tactics.V2.Derived.compute"
] | [] | false | false | true | false | false | let big_or'_nil (#a: Type) (f: (a -> Type)) =
| FStar.Tactics.Effect.assert_by_tactic (big_or' f [] == False)
(fun _ ->
();
(T.compute ())) | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.qas_nat4 | val qas_nat4 : f: Hacl.Spec.K256.Scalar.qelem4 -> Prims.int | let qas_nat4 (f:qelem4) =
let (f0, f1, f2, f3) = f in
v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 24,
"start_col": 0,
"start_line": 22
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Hacl.Spec.K256.Scalar.qelem4 -> Prims.int | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem4",
"Lib.IntTypes.uint64",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.int"
] | [] | false | false | false | true | false | let qas_nat4 (f: qelem4) =
| let f0, f1, f2, f3 = f in
v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192 | false | |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.is_qelem_zero_vartime4 | val is_qelem_zero_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | let is_qelem_zero_vartime4 ((f0,f1,f2,f3): qelem4) : bool =
let open Lib.RawIntTypes in
u64_to_UInt64 f0 =. 0uL &&
u64_to_UInt64 f1 =. 0uL &&
u64_to_UInt64 f2 =. 0uL &&
u64_to_UInt64 f3 =. 0uL | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 50,
"start_col": 0,
"start_line": 45
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem4",
"Lib.IntTypes.uint64",
"Prims.op_AmpAmp",
"Lib.IntTypes.op_Equals_Dot",
"Lib.IntTypes.U64",
"Lib.RawIntTypes.u64_to_UInt64",
"FStar.UInt64.__uint_to_t",
"Prims.bool"
] | [] | false | false | false | true | false | let is_qelem_zero_vartime4 (f0, f1, f2, f3: qelem4) : bool =
| let open Lib.RawIntTypes in
u64_to_UInt64 f0 =. 0uL && u64_to_UInt64 f1 =. 0uL && u64_to_UInt64 f2 =. 0uL &&
u64_to_UInt64 f3 =. 0uL | false | |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.qelem4 | val qelem4 : Type0 | let qelem4 = uint64 & uint64 & uint64 & uint64 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 17,
"start_col": 0,
"start_line": 17
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple4",
"Lib.IntTypes.uint64"
] | [] | false | false | false | true | true | let qelem4 =
| uint64 & uint64 & uint64 & uint64 | false | |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.is_qelem_lt_pow2_128_vartime4 | val is_qelem_lt_pow2_128_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | let is_qelem_lt_pow2_128_vartime4 ((a0,a1,a2,a3): qelem4) : bool =
let open Lib.RawIntTypes in
u64_to_UInt64 a2 =. 0uL && u64_to_UInt64 a3 =. 0uL | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 106,
"start_col": 0,
"start_line": 104
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem4",
"Lib.IntTypes.uint64",
"Prims.op_AmpAmp",
"Lib.IntTypes.op_Equals_Dot",
"Lib.IntTypes.U64",
"Lib.RawIntTypes.u64_to_UInt64",
"FStar.UInt64.__uint_to_t",
"Prims.bool"
] | [] | false | false | false | true | false | let is_qelem_lt_pow2_128_vartime4 (a0, a1, a2, a3: qelem4) : bool =
| let open Lib.RawIntTypes in u64_to_UInt64 a2 =. 0uL && u64_to_UInt64 a3 =. 0uL | false | |
FStar.BigOps.fst | FStar.BigOps.big_and'_cons | val big_and'_cons (#a: Type) (f: (a -> Type)) (hd: a) (tl: list a)
: Lemma (big_and' f (hd :: tl) == (f hd /\ big_and' f tl)) | val big_and'_cons (#a: Type) (f: (a -> Type)) (hd: a) (tl: list a)
: Lemma (big_and' f (hd :: tl) == (f hd /\ big_and' f tl)) | let big_and'_cons (#a:Type) (f:a -> Type) (hd:a) (tl:list a)
= assert (big_and' f (hd :: tl) == (f hd /\ big_and' f tl)) by (T.compute()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 38,
"start_col": 0,
"start_line": 37
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> hd: a -> tl: Prims.list a
-> FStar.Pervasives.Lemma
(ensures FStar.BigOps.big_and' f (hd :: tl) == f hd /\ FStar.BigOps.big_and' f tl) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.big_and'",
"Prims.Cons",
"Prims.l_and",
"Prims.unit",
"FStar.Tactics.V2.Derived.compute"
] | [] | false | false | true | false | false | let big_and'_cons (#a: Type) (f: (a -> Type)) (hd: a) (tl: list a) =
| FStar.Tactics.Effect.assert_by_tactic (big_and' f (hd :: tl) == (f hd /\ big_and' f tl))
(fun _ ->
();
(T.compute ())) | false |
FStar.BigOps.fst | FStar.BigOps.big_and'_prop | val big_and'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_and' f l) `subtype_of` unit) | val big_and'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_and' f l) `subtype_of` unit) | let big_and'_prop (#a:Type) (f:a -> Type) (l:list a)
= match l with
| [] -> big_and'_nil f
| hd::tl -> big_and'_cons f hd tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 43,
"start_col": 0,
"start_line": 40
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.big_and' f l) Prims.unit) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.big_and'_nil",
"FStar.BigOps.big_and'_cons",
"Prims.unit"
] | [] | false | false | true | false | false | let big_and'_prop (#a: Type) (f: (a -> Type)) (l: list a) =
| match l with
| [] -> big_and'_nil f
| hd :: tl -> big_and'_cons f hd tl | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.is_qelem_eq_vartime4 | val is_qelem_eq_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | let is_qelem_eq_vartime4 ((a0,a1,a2,a3): qelem4) ((b0,b1,b2,b3): qelem4) : bool =
let open Lib.RawIntTypes in
u64_to_UInt64 a0 =. u64_to_UInt64 b0 &&
u64_to_UInt64 a1 =. u64_to_UInt64 b1 &&
u64_to_UInt64 a2 =. u64_to_UInt64 b2 &&
u64_to_UInt64 a3 =. u64_to_UInt64 b3 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 100,
"start_col": 0,
"start_line": 95
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Hacl.Spec.K256.Scalar.qelem4 -> _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem4",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple4",
"Lib.IntTypes.uint64",
"Prims.op_AmpAmp",
"Lib.IntTypes.op_Equals_Dot",
"Lib.IntTypes.U64",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.bool"
] | [] | false | false | false | true | false | let is_qelem_eq_vartime4 (a0, a1, a2, a3: qelem4) (b0, b1, b2, b3: qelem4) : bool =
| let open Lib.RawIntTypes in
u64_to_UInt64 a0 =. u64_to_UInt64 b0 && u64_to_UInt64 a1 =. u64_to_UInt64 b1 &&
u64_to_UInt64 a2 =. u64_to_UInt64 b2 &&
u64_to_UInt64 a3 =. u64_to_UInt64 b3 | false | |
FStar.BigOps.fst | FStar.BigOps.pairwise_or'_nil | val pairwise_or'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_or' f [] == False) | val pairwise_or'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_or' f [] == False) | let pairwise_or'_nil (#a:Type) (f:a -> a -> Type0)
= assert (pairwise_or' f [] == False) by (T.compute()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 108,
"start_col": 0,
"start_line": 107
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0)
-> FStar.Pervasives.Lemma (ensures FStar.BigOps.pairwise_or' f [] == Prims.l_False) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.pairwise_or'",
"Prims.Nil",
"Prims.l_False",
"Prims.unit",
"FStar.Tactics.V2.Derived.compute"
] | [] | false | false | true | false | false | let pairwise_or'_nil (#a: Type) (f: (a -> a -> Type0)) =
| FStar.Tactics.Effect.assert_by_tactic (pairwise_or' f [] == False)
(fun _ ->
();
(T.compute ())) | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.is_qelem_lt_q_vartime4 | val is_qelem_lt_q_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | let is_qelem_lt_q_vartime4 ((a0,a1,a2,a3): qelem4) : bool =
let open Lib.RawIntTypes in
if u64_to_UInt64 a3 <. 0xffffffffffffffffuL then true
else begin
if u64_to_UInt64 a2 <. 0xfffffffffffffffeuL then true
else begin
if u64_to_UInt64 a2 >. 0xfffffffffffffffeuL then false
else begin
if... | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 69,
"start_col": 0,
"start_line": 54
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem4",
"Lib.IntTypes.uint64",
"Lib.IntTypes.op_Less_Dot",
"Lib.IntTypes.U64",
"Lib.RawIntTypes.u64_to_UInt64",
"FStar.UInt64.__uint_to_t",
"Prims.bool",
"Lib.IntTypes.op_Greater_Dot"
] | [] | false | false | false | true | false | let is_qelem_lt_q_vartime4 (a0, a1, a2, a3: qelem4) : bool =
| let open Lib.RawIntTypes in
if u64_to_UInt64 a3 <. 0xffffffffffffffffuL
then true
else
if u64_to_UInt64 a2 <. 0xfffffffffffffffeuL
then true
else
if u64_to_UInt64 a2 >. 0xfffffffffffffffeuL
then false
else
if u64_to_UInt64 a1 <. 0xbaaedce6af48a03buL
then true
else
if u64_to_U... | false | |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.is_qelem_le_q_halved_vartime4 | val is_qelem_le_q_halved_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | let is_qelem_le_q_halved_vartime4 ((a0,a1,a2,a3): qelem4) : bool =
let open Lib.RawIntTypes in
if u64_to_UInt64 a3 <. 0x7fffffffffffffffuL then true
else begin
if u64_to_UInt64 a3 >. 0x7fffffffffffffffuL then false
else begin
if u64_to_UInt64 a2 <. 0xffffffffffffffffuL then true
else begin
... | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 91,
"start_col": 0,
"start_line": 73
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem4",
"Lib.IntTypes.uint64",
"Lib.IntTypes.op_Less_Dot",
"Lib.IntTypes.U64",
"Lib.RawIntTypes.u64_to_UInt64",
"FStar.UInt64.__uint_to_t",
"Prims.bool",
"Lib.IntTypes.op_Greater_Dot",
"Lib.IntTypes.op_Less_Equals_Dot"
] | [] | false | false | false | true | false | let is_qelem_le_q_halved_vartime4 (a0, a1, a2, a3: qelem4) : bool =
| let open Lib.RawIntTypes in
if u64_to_UInt64 a3 <. 0x7fffffffffffffffuL
then true
else
if u64_to_UInt64 a3 >. 0x7fffffffffffffffuL
then false
else
if u64_to_UInt64 a2 <. 0xffffffffffffffffuL
then true
else
if u64_to_UInt64 a2 >. 0xffffffffffffffffuL
then false
else
if u64_to_... | false | |
FStar.BigOps.fst | FStar.BigOps.pairwise_and'_nil | val pairwise_and'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_and' f [] == True) | val pairwise_and'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_and' f [] == True) | let pairwise_and'_nil (#a:Type) (f:a -> a -> Type0)
= assert (pairwise_and' f [] == True) by (T.compute()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 69,
"start_col": 0,
"start_line": 68
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0)
-> FStar.Pervasives.Lemma (ensures FStar.BigOps.pairwise_and' f [] == Prims.l_True) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.pairwise_and'",
"Prims.Nil",
"Prims.l_True",
"Prims.unit",
"FStar.Tactics.V2.Derived.compute"
] | [] | false | false | true | false | false | let pairwise_and'_nil (#a: Type) (f: (a -> a -> Type0)) =
| FStar.Tactics.Effect.assert_by_tactic (pairwise_and' f [] == True)
(fun _ ->
();
(T.compute ())) | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_and'_cons | val pairwise_and'_cons (#a: Type) (f: (a -> a -> Type0)) (hd: a) (tl: list a)
: Lemma (pairwise_and' f (hd :: tl) == (big_and' (f hd) tl /\ pairwise_and' f tl)) | val pairwise_and'_cons (#a: Type) (f: (a -> a -> Type0)) (hd: a) (tl: list a)
: Lemma (pairwise_and' f (hd :: tl) == (big_and' (f hd) tl /\ pairwise_and' f tl)) | let pairwise_and'_cons (#a:Type) (f:a -> a -> Type) (hd:a) (tl:list a)
= assert (pairwise_and' f (hd::tl) == (big_and' (f hd) tl /\ pairwise_and' f tl))
by (T.trefl()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 73,
"start_col": 0,
"start_line": 71
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> hd: a -> tl: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
FStar.BigOps.pairwise_and' f (hd :: tl) ==
FStar.BigOps.big_and' (f hd) tl /\ FStar.BigOps.pairwise_and' f tl) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.pairwise_and'",
"Prims.Cons",
"Prims.l_and",
"FStar.BigOps.big_and'",
"Prims.unit",
"FStar.Tactics.V2.Derived.trefl"
] | [] | false | false | true | false | false | let pairwise_and'_cons (#a: Type) (f: (a -> a -> Type)) (hd: a) (tl: list a) =
| FStar.Tactics.Effect.assert_by_tactic (pairwise_and' f (hd :: tl) ==
(big_and' (f hd) tl /\ pairwise_and' f tl))
(fun _ ->
();
(T.trefl ())) | false |
FStar.BigOps.fst | FStar.BigOps.big_or'_prop | val big_or'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_or' f l) `subtype_of` unit) | val big_or'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_or' f l) `subtype_of` unit) | let big_or'_prop (#a:Type) (f:a -> Type) (l:list a)
= match l with
| [] -> big_or'_nil f
| hd::tl -> big_or'_cons f hd tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 60,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.big_or' f l) Prims.unit) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.big_or'_nil",
"FStar.BigOps.big_or'_cons",
"Prims.unit"
] | [] | false | false | true | false | false | let big_or'_prop (#a: Type) (f: (a -> Type)) (l: list a) =
| match l with
| [] -> big_or'_nil f
| hd :: tl -> big_or'_cons f hd tl | false |
Vale.Poly1305.X64.fst | Vale.Poly1305.X64.va_lemma_Poly1305 | val va_lemma_Poly1305 : va_b0:va_code -> va_s0:va_state -> win:bool -> ctx_b:buffer64 ->
inp_b:buffer64 -> len_in:nat64 -> finish_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Poly1305 win) va_s0 /\ va_get_ok va_s0 /\ (let
(ctx_in:(va_int_range 0 18446744073709551615)) = (i... | val va_lemma_Poly1305 : va_b0:va_code -> va_s0:va_state -> win:bool -> ctx_b:buffer64 ->
inp_b:buffer64 -> len_in:nat64 -> finish_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Poly1305 win) va_s0 /\ va_get_ok va_s0 /\ (let
(ctx_in:(va_int_range 0 18446744073709551615)) = (i... | let va_lemma_Poly1305 va_b0 va_s0 win ctx_b inp_b len_in finish_in =
let (va_mods:va_mods_t) = [va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet
1; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR12;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64... | {
"file_name": "obj/Vale.Poly1305.X64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 2992,
"start_col": 0,
"start_line": 2905
} | module Vale.Poly1305.X64
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Va... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Poly1305.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
ctx_b: Vale.X64.Memory.buffer64 ->
inp_b: Vale.X64.Memory.buffer64 ->
len_in: Vale.X64.Memory.nat64 ->
finish_in: Vale.X64.Memory.nat64
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.QuickCodes.fuel",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.Quick... | [] | false | false | false | false | false | let va_lemma_Poly1305 va_b0 va_s0 win ctx_b inp_b len_in finish_in =
| let va_mods:va_mods_t =
[
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 1; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp;
... | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_and'_prop | val pairwise_and'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_and' f l) `subtype_of` unit) | val pairwise_and'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_and' f l) `subtype_of` unit) | let pairwise_and'_prop (#a:Type) (f:a -> a -> Type) (l:list a)
= match l with
| [] -> pairwise_and'_nil f
| hd::tl -> pairwise_and'_cons f hd tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 78,
"start_col": 0,
"start_line": 75
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.pairwise_and' f l) Prims.unit) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.pairwise_and'_nil",
"FStar.BigOps.pairwise_and'_cons",
"Prims.unit"
] | [] | false | false | true | false | false | let pairwise_and'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a) =
| match l with
| [] -> pairwise_and'_nil f
| hd :: tl -> pairwise_and'_cons f hd tl | false |
FStar.BigOps.fst | FStar.BigOps.big_or'_cons | val big_or'_cons (#a: Type) (f: (a -> Type)) (hd: a) (tl: list a)
: Lemma (big_or' f (hd :: tl) == (f hd \/ big_or' f tl)) | val big_or'_cons (#a: Type) (f: (a -> Type)) (hd: a) (tl: list a)
: Lemma (big_or' f (hd :: tl) == (f hd \/ big_or' f tl)) | let big_or'_cons (#a:Type) (f:a -> Type) (hd:a) (tl:list a)
= assert (big_or' f (hd :: tl) == (f hd \/ big_or' f tl)) by (T.compute()) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 55,
"start_col": 0,
"start_line": 54
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> hd: a -> tl: Prims.list a
-> FStar.Pervasives.Lemma
(ensures FStar.BigOps.big_or' f (hd :: tl) == (f hd \/ FStar.BigOps.big_or' f tl)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BigOps.big_or'",
"Prims.Cons",
"Prims.l_or",
"Prims.unit",
"FStar.Tactics.V2.Derived.compute"
] | [] | false | false | true | false | false | let big_or'_cons (#a: Type) (f: (a -> Type)) (hd: a) (tl: list a) =
| FStar.Tactics.Effect.assert_by_tactic (big_or' f (hd :: tl) == (f hd \/ big_or' f tl))
(fun _ ->
();
(T.compute ())) | false |
Vale.Poly1305.X64.fst | Vale.Poly1305.X64.va_lemma_Poly1305_impl | val va_lemma_Poly1305_impl : va_b0:va_code -> va_s0:va_state -> key_r:nat128 -> key_s:nat128 ->
ctx_b:buffer64 -> inp_b:buffer64 -> finish:nat64
-> Ghost (va_state & va_fuel & int)
(requires (va_require_total va_b0 (va_code_Poly1305_impl ()) va_s0 /\ va_get_ok va_s0 /\ (let
(n:(va_int_range 184467440737095516... | val va_lemma_Poly1305_impl : va_b0:va_code -> va_s0:va_state -> key_r:nat128 -> key_s:nat128 ->
ctx_b:buffer64 -> inp_b:buffer64 -> finish:nat64
-> Ghost (va_state & va_fuel & int)
(requires (va_require_total va_b0 (va_code_Poly1305_impl ()) va_s0 /\ va_get_ok va_s0 /\ (let
(n:(va_int_range 184467440737095516... | let va_lemma_Poly1305_impl va_b0 va_s0 key_r key_s ctx_b inp_b finish =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 1; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64
rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRbp; va_Mod... | {
"file_name": "obj/Vale.Poly1305.X64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 2658,
"start_col": 0,
"start_line": 2602
} | module Vale.Poly1305.X64
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Va... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Poly1305.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
key_r: Vale.X64.Machine_s.nat128 ->
key_s: Vale.X64.Machine_s.nat128 ->
ctx_b: Vale.X64.Memory.buffer64 ->
inp_b: Vale.X64.Memory.buffer64 ->
finish: Vale.X64.Memory.nat64
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X6... | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Machine_s.nat128",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.QuickCodes.fuel",
"Prims.int",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.Decls.va_fuel",
"Prims.unit",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"... | [] | false | false | false | false | false | let va_lemma_Poly1305_impl va_b0 va_s0 key_r key_s ctx_b inp_b finish =
| let va_mods:va_mods_t =
[
va_Mod_mem_heaplet 1; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRbp; va_Mod_reg64 rRbx; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRdx;... | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_and'_forall_no_repeats | val pairwise_and'_forall_no_repeats (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ L.no_repeats_p l)
(ensures (pairwise_and' f l <==> (forall x y. L.memP x l /\ L.memP y l /\ x =!= y ==> f x y))) | val pairwise_and'_forall_no_repeats (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ L.no_repeats_p l)
(ensures (pairwise_and' f l <==> (forall x y. L.memP x l /\ L.memP y l /\ x =!= y ==> f x y))) | let rec pairwise_and'_forall_no_repeats (#a:Type) (f: a -> a -> Type) (l:list a)
= match l with
| [] -> pairwise_and'_nil f
| hd::tl ->
pairwise_and'_cons f hd tl;
pairwise_and'_forall_no_repeats f tl;
big_and'_forall (f hd) tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 104,
"start_col": 0,
"start_line": 98
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires FStar.BigOps.symmetric f /\ FStar.List.Tot.Base.no_repeats_p l)
(ensures
FStar.BigOps.pairwise_and' f l <==>
(forall (x: a) (y: a).
FStar.List.Tot.Base.memP x l /\ FStar.List.Tot.Base.memP y l /\ ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.pairwise_and'_nil",
"FStar.BigOps.big_and'_forall",
"Prims.unit",
"FStar.BigOps.pairwise_and'_forall_no_repeats",
"FStar.BigOps.pairwise_and'_cons"
] | [
"recursion"
] | false | false | true | false | false | let rec pairwise_and'_forall_no_repeats (#a: Type) (f: (a -> a -> Type)) (l: list a) =
| match l with
| [] -> pairwise_and'_nil f
| hd :: tl ->
pairwise_and'_cons f hd tl;
pairwise_and'_forall_no_repeats f tl;
big_and'_forall (f hd) tl | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_or'_prop | val pairwise_or'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_or' f l) `subtype_of` unit) | val pairwise_or'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_or' f l) `subtype_of` unit) | let pairwise_or'_prop (#a:Type) (f:a -> a -> Type) (l:list a)
= match l with
| [] -> pairwise_or'_nil f
| hd::tl -> pairwise_or'_cons f hd tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 116,
"start_col": 0,
"start_line": 113
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.pairwise_or' f l) Prims.unit) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.pairwise_or'_nil",
"FStar.BigOps.pairwise_or'_cons",
"Prims.unit"
] | [] | false | false | true | false | false | let pairwise_or'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a) =
| match l with
| [] -> pairwise_or'_nil f
| hd :: tl -> pairwise_or'_cons f hd tl | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_and'_forall | val pairwise_and'_forall (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ reflexive f)
(ensures (pairwise_and' f l <==> (forall x y. L.memP x l /\ L.memP y l ==> f x y))) | val pairwise_and'_forall (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ reflexive f)
(ensures (pairwise_and' f l <==> (forall x y. L.memP x l /\ L.memP y l ==> f x y))) | let rec pairwise_and'_forall (#a:Type) (f: a -> a -> Type) (l:list a)
= match l with
| [] -> pairwise_and'_nil f
| hd::tl ->
pairwise_and'_cons f hd tl;
pairwise_and'_forall f tl;
big_and'_forall (f hd) tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 96,
"start_col": 0,
"start_line": 90
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (requires FStar.BigOps.symmetric f /\ FStar.BigOps.reflexive f)
(ensures
FStar.BigOps.pairwise_and' f l <==>
(forall (x: a) (y: a).
FStar.List.Tot.Base.memP x l /\ FStar.List.Tot.Base.memP y l ==> f x y)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.pairwise_and'_nil",
"FStar.BigOps.big_and'_forall",
"Prims.unit",
"FStar.BigOps.pairwise_and'_forall",
"FStar.BigOps.pairwise_and'_cons"
] | [
"recursion"
] | false | false | true | false | false | let rec pairwise_and'_forall (#a: Type) (f: (a -> a -> Type)) (l: list a) =
| match l with
| [] -> pairwise_and'_nil f
| hd :: tl ->
pairwise_and'_cons f hd tl;
pairwise_and'_forall f tl;
big_and'_forall (f hd) tl | false |
FStar.BigOps.fst | FStar.BigOps.big_and'_forall | val big_and'_forall (#a: Type) (f: (a -> Type)) (l: list a)
: Lemma (big_and' f l <==> (forall x. L.memP x l ==> f x)) | val big_and'_forall (#a: Type) (f: (a -> Type)) (l: list a)
: Lemma (big_and' f l <==> (forall x. L.memP x l ==> f x)) | let rec big_and'_forall (#a:Type) (f:a -> Type) (l:list a)
= match l with
| [] -> big_and'_nil f; ()
| hd::tl -> big_and'_cons f hd tl; big_and'_forall f tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 48,
"start_col": 0,
"start_line": 45
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures FStar.BigOps.big_and' f l <==> (forall (x: a). FStar.List.Tot.Base.memP x l ==> f x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.unit",
"FStar.BigOps.big_and'_nil",
"FStar.BigOps.big_and'_forall",
"FStar.BigOps.big_and'_cons"
] | [
"recursion"
] | false | false | true | false | false | let rec big_and'_forall (#a: Type) (f: (a -> Type)) (l: list a) =
| match l with
| [] ->
big_and'_nil f;
()
| hd :: tl ->
big_and'_cons f hd tl;
big_and'_forall f tl | false |
FStar.BigOps.fst | FStar.BigOps.big_or'_exists | val big_or'_exists (#a: Type) (f: (a -> Type)) (l: list a)
: Lemma (big_or' f l <==> (exists x. L.memP x l /\ f x)) | val big_or'_exists (#a: Type) (f: (a -> Type)) (l: list a)
: Lemma (big_or' f l <==> (exists x. L.memP x l /\ f x)) | let rec big_or'_exists (#a:Type) (f:a -> Type) (l:list a)
= match l with
| [] -> big_or'_nil f; ()
| hd::tl -> big_or'_cons f hd tl; big_or'_exists f tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 65,
"start_col": 0,
"start_line": 62
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures FStar.BigOps.big_or' f l <==> (exists (x: a). FStar.List.Tot.Base.memP x l /\ f x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.unit",
"FStar.BigOps.big_or'_nil",
"FStar.BigOps.big_or'_exists",
"FStar.BigOps.big_or'_cons"
] | [
"recursion"
] | false | false | true | false | false | let rec big_or'_exists (#a: Type) (f: (a -> Type)) (l: list a) =
| match l with
| [] ->
big_or'_nil f;
()
| hd :: tl ->
big_or'_cons f hd tl;
big_or'_exists f tl | false |
FStar.Algebra.CommMonoid.Fold.Nested.fst | FStar.Algebra.CommMonoid.Fold.Nested.matrix_seq | val matrix_seq : generator: FStar.Matrix.matrix_generator c m r
-> s:
FStar.Seq.Base.seq c
{ FStar.Seq.Base.length s = m * r /\
(forall (ij: FStar.IntegerIntervals.under (m * r)).
FStar.Seq.Base.index s ij ==
FStar.Seq.Base.index s
(FStar.Matrix.get_ij m r (FSta... | let matrix_seq #c #m #r (generator: matrix_generator c m r) =
seq_of_matrix (Matrix.init generator) | {
"file_name": "ulib/FStar.Algebra.CommMonoid.Fold.Nested.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | (*
Copyright 2022 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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Matrix.fsti.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar... | [
{
"abbrev": false,
"full_module": "FStar.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | generator: FStar.Matrix.matrix_generator c m r
-> s:
FStar.Seq.Base.seq c
{ FStar.Seq.Base.length s = m * r /\
(forall (ij: FStar.IntegerIntervals.under (m * r)).
FStar.Seq.Base.index s ij ==
FStar.Seq.Base.index s
(FStar.Matrix.get_ij m r (FStar.Matrix.get_i m ... | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.eq2",
... | [] | false | false | false | false | false | let matrix_seq #c #m #r (generator: matrix_generator c m r) =
| seq_of_matrix (Matrix.init generator) | false | |
FStar.BigOps.fst | FStar.BigOps.pairwise_or'_cons | val pairwise_or'_cons (#a: Type) (f: (a -> a -> Type0)) (hd: a) (tl: list a)
: Lemma (pairwise_or' f (hd :: tl) == (big_or' (f hd) tl \/ pairwise_or' f tl)) | val pairwise_or'_cons (#a: Type) (f: (a -> a -> Type0)) (hd: a) (tl: list a)
: Lemma (pairwise_or' f (hd :: tl) == (big_or' (f hd) tl \/ pairwise_or' f tl)) | let pairwise_or'_cons (#a:Type) (f:a -> a -> Type) (hd:a) (tl:list a)
= assert (pairwise_or' f (hd::tl) == (big_or' (f hd) tl \/ pairwise_or' f tl)) | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 111,
"start_col": 0,
"start_line": 110
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> hd: a -> tl: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
FStar.BigOps.pairwise_or' f (hd :: tl) ==
(FStar.BigOps.big_or' (f hd) tl \/ FStar.BigOps.pairwise_or' f tl)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims._assert",
"Prims.eq2",
"FStar.BigOps.pairwise_or'",
"Prims.Cons",
"Prims.l_or",
"FStar.BigOps.big_or'",
"Prims.unit"
] | [] | true | false | true | false | false | let pairwise_or'_cons (#a: Type) (f: (a -> a -> Type)) (hd: a) (tl: list a) =
| assert (pairwise_or' f (hd :: tl) == (big_or' (f hd) tl \/ pairwise_or' f tl)) | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_or'_exists_no_repeats | val pairwise_or'_exists_no_repeats (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ L.no_repeats_p l)
(ensures (pairwise_or' f l <==> (exists x y. L.memP x l /\ L.memP y l /\ x =!= y /\ f x y))) | val pairwise_or'_exists_no_repeats (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ L.no_repeats_p l)
(ensures (pairwise_or' f l <==> (exists x y. L.memP x l /\ L.memP y l /\ x =!= y /\ f x y))) | let rec pairwise_or'_exists_no_repeats (#a:Type) (f: a -> a -> Type) (l:list a)
= match l with
| [] -> pairwise_or'_nil f
| hd::tl ->
pairwise_or'_cons f hd tl;
pairwise_or'_exists_no_repeats f tl;
big_or'_exists (f hd) tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 132,
"start_col": 0,
"start_line": 126
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires FStar.BigOps.symmetric f /\ FStar.List.Tot.Base.no_repeats_p l)
(ensures
FStar.BigOps.pairwise_or' f l <==>
(exists (x: a) (y: a).
FStar.List.Tot.Base.memP x l /\ FStar.List.Tot.Base.memP y l /\ ~... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.pairwise_or'_nil",
"FStar.BigOps.big_or'_exists",
"Prims.unit",
"FStar.BigOps.pairwise_or'_exists_no_repeats",
"FStar.BigOps.pairwise_or'_cons"
] | [
"recursion"
] | false | false | true | false | false | let rec pairwise_or'_exists_no_repeats (#a: Type) (f: (a -> a -> Type)) (l: list a) =
| match l with
| [] -> pairwise_or'_nil f
| hd :: tl ->
pairwise_or'_cons f hd tl;
pairwise_or'_exists_no_repeats f tl;
big_or'_exists (f hd) tl | false |
FStar.BigOps.fst | FStar.BigOps.pairwise_or'_exists | val pairwise_or'_exists (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ anti_reflexive f)
(ensures (pairwise_or' f l <==> (exists x y. L.memP x l /\ L.memP y l /\ f x y))) | val pairwise_or'_exists (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma (requires symmetric f /\ anti_reflexive f)
(ensures (pairwise_or' f l <==> (exists x y. L.memP x l /\ L.memP y l /\ f x y))) | let rec pairwise_or'_exists (#a:Type) (f: a -> a -> Type) (l:list a)
= match l with
| [] -> pairwise_or'_nil f
| hd::tl ->
pairwise_or'_cons f hd tl;
pairwise_or'_exists f tl;
big_or'_exists (f hd) tl | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 124,
"start_col": 0,
"start_line": 118
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.BigOps.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (requires FStar.BigOps.symmetric f /\ FStar.BigOps.anti_reflexive f)
(ensures
FStar.BigOps.pairwise_or' f l <==>
(exists (x: a) (y: a). FStar.List.Tot.Base.memP x l /\ FStar.List.Tot.Base.memP y l /\ f x y
)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.BigOps.pairwise_or'_nil",
"FStar.BigOps.big_or'_exists",
"Prims.unit",
"FStar.BigOps.pairwise_or'_exists",
"FStar.BigOps.pairwise_or'_cons"
] | [
"recursion"
] | false | false | true | false | false | let rec pairwise_or'_exists (#a: Type) (f: (a -> a -> Type)) (l: list a) =
| match l with
| [] -> pairwise_or'_nil f
| hd :: tl ->
pairwise_or'_cons f hd tl;
pairwise_or'_exists f tl;
big_or'_exists (f hd) tl | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.gctr128_bytes | val gctr128_bytes : Vale.Interop.Base.normal (s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t s) | let gctr128_bytes //: normal ((s:Ghost.erased (Seq.seq nat32)) -> lowstar_gctr128_t s)
= as_normal_t #((s:Ghost.erased (Seq.seq nat32)) -> lowstar_gctr128_t s) (fun (s:Ghost.erased (Seq.seq nat32)) -> lowstar_gctr128 s) | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 134,
"end_line": 258,
"start_col": 0,
"start_line": 257
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.Interop.Base.normal (s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t s) | Prims.Tot | [
"total"
] | [] | [
"Vale.Stdcalls.X64.GCTR.as_normal_t",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t",
"Vale.Stdcalls.X64.GCTR.lowstar_gctr128"
] | [] | false | false | false | false | false | let gctr128_bytes =
| as_normal_t #(s: Ghost.erased (Seq.seq nat32) -> lowstar_gctr128_t s)
(fun (s: Ghost.erased (Seq.seq nat32)) -> lowstar_gctr128 s) | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.as_normal_t | val as_normal_t (#a: Type) (x: a) : normal a | val as_normal_t (#a: Type) (x: a) : normal a | let as_normal_t (#a:Type) (x:a) : normal a = x | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 33,
"start_col": 0,
"start_line": 33
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> Vale.Interop.Base.normal a | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.normal"
] | [] | false | false | false | true | false | let as_normal_t (#a: Type) (x: a) : normal a =
| x | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.qelem_lseq | val qelem_lseq : Type0 | let qelem_lseq = lseq uint64 4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 19,
"start_col": 0,
"start_line": 19
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64"
] | [] | false | false | false | true | true | let qelem_lseq =
| lseq uint64 4 | false | |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.make_pow2_256_minus_order_k256 | val make_pow2_256_minus_order_k256: unit -> Pure qelem4
(requires True)
(ensures fun r -> qas_nat4 r = pow2 256 - S.q) | val make_pow2_256_minus_order_k256: unit -> Pure qelem4
(requires True)
(ensures fun r -> qas_nat4 r = pow2 256 - S.q) | let make_pow2_256_minus_order_k256 () =
[@inline_let]
let r =
(u64 0x402da1732fc9bebf,
u64 0x4551231950b75fc4,
u64 0x1,
u64 0x0) in
assert_norm (qas_nat4 r = pow2 256 - S.q);
r | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 41,
"start_col": 0,
"start_line": 32
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> Prims.Pure Hacl.Spec.K256.Scalar.qelem4 | Prims.Pure | [] | [] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.K256.Scalar.qas_nat4",
"Prims.op_Subtraction",
"Prims.pow2",
"Spec.K256.PointOps.q",
"FStar.Pervasives.Native.tuple4",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FSta... | [] | false | false | false | false | false | let make_pow2_256_minus_order_k256 () =
| [@@ inline_let ]let r = (u64 0x402da1732fc9bebf, u64 0x4551231950b75fc4, u64 0x1, u64 0x0) in
assert_norm (qas_nat4 r = pow2 256 - S.q);
r | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.dom | val dom:dom: list td {List.length dom <= 20} | val dom:dom: list td {List.length dom <= 20} | let (dom: list td{List.length dom <= 20}) =
let y = [t128_no_mod; tuint64; t128_mod; t128_mod; t128_no_mod; t128_no_mod; tuint64] in
assert_norm (List.length y = 7);
y | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 48,
"start_col": 0,
"start_line": 45
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | dom: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length dom <= 20} | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Vale.Interop.Base.td",
"Prims.list",
"Prims.Cons",
"Vale.Stdcalls.X64.GCTR.t128_no_mod",
"Vale.Stdcalls.X64.GCTR.tuint64",
"Vale.Stdcalls.X64.GCTR.t128_mod",
"Prims.Nil... | [] | false | false | false | false | false | let dom:dom: list td {List.length dom <= 20} =
| let y = [t128_no_mod; tuint64; t128_mod; t128_mod; t128_no_mod; t128_no_mod; tuint64] in
assert_norm (List.length y = 7);
y | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.mod_short_lseq | val mod_short_lseq: a:qelem_lseq -> qelem_lseq | val mod_short_lseq: a:qelem_lseq -> qelem_lseq | let mod_short_lseq a =
let (t0,t1,t2,t3) = make_pow2_256_minus_order_k256 () in
let tmp = create4 t0 t1 t2 t3 in
let c, out = SB.bn_add a tmp in
let mask = u64 0 -. c in
map2 (BB.mask_select mask) out a | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 117,
"start_col": 0,
"start_line": 111
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.K256.Scalar.qelem_lseq -> Hacl.Spec.K256.Scalar.qelem_lseq | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.K256.Scalar.qelem_lseq",
"Lib.IntTypes.uint64",
"Hacl.Spec.Bignum.Base.carry",
"Lib.IntTypes.U64",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.map2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntT... | [] | false | false | false | true | false | let mod_short_lseq a =
| let t0, t1, t2, t3 = make_pow2_256_minus_order_k256 () in
let tmp = create4 t0 t1 t2 t3 in
let c, out = SB.bn_add a tmp in
let mask = u64 0 -. c in
map2 (BB.mask_select mask) out a | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.as_t | val as_t (#a: Type) (x: normal a) : a | val as_t (#a: Type) (x: normal a) : a | let as_t (#a:Type) (x:normal a) : a = x | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 31,
"start_col": 0,
"start_line": 31
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Vale.Interop.Base.normal a -> a | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.normal"
] | [] | false | false | false | true | false | let as_t (#a: Type) (x: normal a) : a =
| x | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.mul_pow2_256_minus_q_lseq_add | val mul_pow2_256_minus_q_lseq_add:
len:size_nat -> resLen:size_nat{2 + len <= resLen /\ 4 <= resLen}
-> a:lseq uint64 len -> e:lseq uint64 4 -> BB.carry U64 & lseq uint64 resLen | val mul_pow2_256_minus_q_lseq_add:
len:size_nat -> resLen:size_nat{2 + len <= resLen /\ 4 <= resLen}
-> a:lseq uint64 len -> e:lseq uint64 4 -> BB.carry U64 & lseq uint64 resLen | let mul_pow2_256_minus_q_lseq_add len resLen a e =
let _, m = mul_pow2_256_minus_q_lseq len resLen a in // a * SECP256K1_N_C
SB.bn_add m e | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 143,
"start_col": 0,
"start_line": 141
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Lib.IntTypes.size_nat ->
resLen: Lib.IntTypes.size_nat{2 + len <= resLen /\ 4 <= resLen} ->
a: Lib.Sequence.lseq Lib.IntTypes.uint64 len ->
e: Lib.Sequence.lseq Lib.IntTypes.uint64 4
-> Hacl.Spec.Bignum.Base.carry Lib.IntTypes.U64 * Lib.Sequence.lseq Lib.IntTypes.uint64 resLen | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Spec.Bignum.Base.carry",
"Lib.IntTypes.U64",
"Hacl.Spec.Bignum.bn_add",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.int_t",
"Lib.IntType... | [] | false | false | false | false | false | let mul_pow2_256_minus_q_lseq_add len resLen a e =
| let _, m = mul_pow2_256_minus_q_lseq len resLen a in
SB.bn_add m e | false |
FStar.Algebra.CommMonoid.Fold.Nested.fst | FStar.Algebra.CommMonoid.Fold.Nested.double_fold_transpose_lemma | val double_fold_transpose_lemma (#c:_) (#eq: _)
(#m0: int) (#mk: not_less_than m0)
(#n0: int) (#nk: not_less_than n0)
(cm: CE.cm c eq)
(offset_gen: ifrom_ito m0 mk -> ifrom_ito n0 nk -> c)
... | val double_fold_transpose_lemma (#c:_) (#eq: _)
(#m0: int) (#mk: not_less_than m0)
(#n0: int) (#nk: not_less_than n0)
(cm: CE.cm c eq)
(offset_gen: ifrom_ito m0 mk -> ifrom_ito n0 nk -> c)
... | let double_fold_transpose_lemma #c #eq
(#m0: int) (#mk: not_less_than m0)
(#n0: int) (#nk: not_less_than n0)
(cm: CE.cm c eq)
(offset_gen: ifrom_ito m0 mk -> ifrom_ito n0 nk -> c)
: Lemma ... | {
"file_name": "ulib/FStar.Algebra.CommMonoid.Fold.Nested.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 92,
"start_col": 0,
"start_line": 45
} | (*
Copyright 2022 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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Matrix.fsti.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar... | [
{
"abbrev": false,
"full_module": "FStar.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
offset_gen:
(_: FStar.IntegerIntervals.ifrom_ito m0 mk -> _: FStar.IntegerIntervals.ifrom_ito n0 nk -> c)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Algebra.CommMonoid.Fold.Nested.double_fold cm offset_gen)
(FStar.Algebra.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.int",
"FStar.IntegerIntervals.not_less_than",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.ifrom_ito",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.unit",
"FStar.Pervasives.a... | [] | false | false | true | false | false | let double_fold_transpose_lemma
#c
#eq
(#m0: int)
(#mk: not_less_than m0)
(#n0: int)
(#nk: not_less_than n0)
(cm: CE.cm c eq)
(offset_gen: (ifrom_ito m0 mk -> ifrom_ito n0 nk -> c))
: Lemma ((double_fold cm offset_gen) `eq.eq` (double_fold cm (transpose_generator offs... | let m = interval_size (ifrom_ito m0 mk) in
let n = interval_size (ifrom_ito n0 nk) in
let gen:matrix_generator c m n = fun i j -> offset_gen (m0 + i) (n0 + j) in
let trans #c #a #b (f: matrix_generator c a b) = transposed_matrix_gen f in
let trans_ofs
#c
(#a1: int)
(#a2: int)
(#b1: int)
(#... | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.lowstar_gctr256 | val lowstar_gctr256 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr256_t s | val lowstar_gctr256 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr256_t s | let lowstar_gctr256 (s:Ghost.erased (Seq.seq nat32)) : lowstar_gctr256_t s =
assert_norm (List.length dom + List.length ([]<:list arg) <= 20);
IX64.wrap_weak_stdcall
code_gctr256
dom
(W.mk_prediction code_gctr256 dom [] ((gctr256_lemma s) code_gctr256 IA.win)) | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 254,
"start_col": 0,
"start_line": 249
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr256_t s | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Interop.X64.wrap_weak_stdcall",
"Vale.Stdcalls.X64.GCTR.code_gctr256",
"Vale.Stdcalls.X64.GCTR.dom",
"Vale.AsLowStar.Wrapper.pre_rel_generic",
"Vale.Interop.X64.max_stdcall",
"Vale.Interop.X64.arg_reg_stdcall",
"Prims.Nil"... | [] | false | false | false | false | false | let lowstar_gctr256 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr256_t s =
| assert_norm (List.length dom + List.length ([] <: list arg) <= 20);
IX64.wrap_weak_stdcall code_gctr256
dom
(W.mk_prediction code_gctr256 dom [] ((gctr256_lemma s) code_gctr256 IA.win)) | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.mul_pow2_256_minus_q_lseq | val mul_pow2_256_minus_q_lseq:
len:size_nat -> resLen:size_nat{2 + len <= resLen}
-> a:lseq uint64 len -> BB.carry U64 & lseq uint64 resLen | val mul_pow2_256_minus_q_lseq:
len:size_nat -> resLen:size_nat{2 + len <= resLen}
-> a:lseq uint64 len -> BB.carry U64 & lseq uint64 resLen | let mul_pow2_256_minus_q_lseq len resLen a =
let t0 = u64 0x402da1732fc9bebf in
let t1 = u64 0x4551231950b75fc4 in
let t01 = create2 t0 t1 in
let m0 = SB.bn_mul a t01 in // a * t01
let m1 = create resLen (u64 0) in
let m1 = update_sub m1 2 len a in // a * t2 * pow2 128
SB.bn_add m1 m0 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 133,
"start_col": 0,
"start_line": 125
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
len: Lib.IntTypes.size_nat ->
resLen: Lib.IntTypes.size_nat{2 + len <= resLen} ->
a: Lib.Sequence.lseq Lib.IntTypes.uint64 len
-> Hacl.Spec.Bignum.Base.carry Lib.IntTypes.U64 * Lib.Sequence.lseq Lib.IntTypes.uint64 resLen | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Spec.Bignum.bn_add",
"Lib.IntTypes.U64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"P... | [] | false | false | false | false | false | let mul_pow2_256_minus_q_lseq len resLen a =
| let t0 = u64 0x402da1732fc9bebf in
let t1 = u64 0x4551231950b75fc4 in
let t01 = create2 t0 t1 in
let m0 = SB.bn_mul a t01 in
let m1 = create resLen (u64 0) in
let m1 = update_sub m1 2 len a in
SB.bn_add m1 m0 | false |
MerkleTree.New.High.Correct.Base.fst | MerkleTree.New.High.Correct.Base.seq_prefix | val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 <= S.length s2} ->
GTot Type0 | val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 <= S.length s2} ->
GTot Type0 | let seq_prefix #a s1 s2 =
S.equal s1 (S.slice s2 0 (S.length s1)) | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 41,
"end_line": 21,
"start_col": 0,
"start_line": 20
} | module MerkleTree.New.High.Correct.Base
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module S = FStar.Seq
module MTS = MerkleTree.Spec
open MerkleTree.New.High
#set-options "--z3rlimit 40 --max_fuel 0 --max_ifuel 0"
/// Sequence helpers
val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 <= FStar.Seq.Base.length s2}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice"
] | [] | false | false | false | false | true | let seq_prefix #a s1 s2 =
| S.equal s1 (S.slice s2 0 (S.length s1)) | false |
MerkleTree.New.High.Correct.Base.fst | MerkleTree.New.High.Correct.Base.empty_hashes | val empty_hashes: (#hsz:pos) -> (len:nat) -> GTot (hs:hashess #hsz {S.length hs = len}) | val empty_hashes: (#hsz:pos) -> (len:nat) -> GTot (hs:hashess #hsz {S.length hs = len}) | let empty_hashes #hsz len = S.create len S.empty | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 48,
"end_line": 40,
"start_col": 0,
"start_line": 40
} | module MerkleTree.New.High.Correct.Base
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module S = FStar.Seq
module MTS = MerkleTree.Spec
open MerkleTree.New.High
#set-options "--z3rlimit 40 --max_fuel 0 --max_ifuel 0"
/// Sequence helpers
val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | len: Prims.nat -> Prims.GTot (hs: MerkleTree.New.High.hashess{FStar.Seq.Base.length hs = len}) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"Prims.nat",
"FStar.Seq.Base.create",
"MerkleTree.New.High.hashes",
"FStar.Seq.Base.empty",
"MerkleTree.New.High.hash",
"MerkleTree.New.High.hashess",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length"
] | [] | false | false | false | false | false | let empty_hashes #hsz len =
| S.create len S.empty | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.gctr128_pre | val gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | val gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | let gctr128_pre : (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom =
fun (s:Ghost.erased (Seq.seq nat32))
(c:V.va_code)
(in_b:b128)
(num_bytes:uint64)
(out_b:b128)
(inout_b:b128)
(keys_b:b128)
(ctr_b:b128)
(num_blocks:uint64)
(va_s0:V.va_state) ->
GC.va_req_Gctr_bytes_stdc... | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 66,
"start_col": 0,
"start_line": 52
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.GCTR.dom | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.GCTR.b128",
"Vale.Stdcalls.X64.GCTR.uint64",
"Vale.X64.Decls.va_state",
"Vale.AES.X64.GCTR.va_req_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_128",... | [] | false | false | false | true | false | let gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom =
| fun
(s: Ghost.erased (Seq.seq nat32))
(c: V.va_code)
(in_b: b128)
(num_bytes: uint64)
(out_b: b128)
(inout_b: b128)
(keys_b: b128)
(ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
->
GC.va_req_Gctr_bytes_stdcall c va_s0 IA.win AES_128 (as_vale_buffer in_b) (UInt64.v num_bytes)
(as_vale... | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t | val lowstar_gctr128_t : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> Type0 | let lowstar_gctr128_t (s:Ghost.erased (Seq.seq nat32)) =
assert_norm (List.length dom + List.length ([]<:list arg) <= 20);
IX64.as_lowstar_sig_t_weak_stdcall
code_gctr128
dom
[]
_
_
(W.mk_prediction code_gctr128 dom [] ((gctr128_lemma s) code_gctr128 IA.win)) | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 142,
"start_col": 0,
"start_line": 134
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Interop.X64.as_lowstar_sig_t_weak_stdcall",
"Vale.Stdcalls.X64.GCTR.code_gctr128",
"Vale.Stdcalls.X64.GCTR.dom",
"Prims.Nil",
"Vale.Interop.Base.arg",
"Vale.AsLowStar.Wrapper.pre_rel_generic",
"Vale.Interop.X64.max_stdcall... | [] | false | false | false | true | true | let lowstar_gctr128_t (s: Ghost.erased (Seq.seq nat32)) =
| assert_norm (List.length dom + List.length ([] <: list arg) <= 20);
IX64.as_lowstar_sig_t_weak_stdcall code_gctr128
dom
[]
_
_
(W.mk_prediction code_gctr128 dom [] ((gctr128_lemma s) code_gctr128 IA.win)) | false | |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.lowstar_gctr128 | val lowstar_gctr128 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr128_t s | val lowstar_gctr128 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr128_t s | let lowstar_gctr128 (s:Ghost.erased (Seq.seq nat32)) : lowstar_gctr128_t s =
assert_norm (List.length dom + List.length ([]<:list arg) <= 20);
IX64.wrap_weak_stdcall
code_gctr128
dom
(W.mk_prediction code_gctr128 dom [] ((gctr128_lemma s) code_gctr128 IA.win)) | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 151,
"start_col": 0,
"start_line": 146
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t s | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Interop.X64.wrap_weak_stdcall",
"Vale.Stdcalls.X64.GCTR.code_gctr128",
"Vale.Stdcalls.X64.GCTR.dom",
"Vale.AsLowStar.Wrapper.pre_rel_generic",
"Vale.Interop.X64.max_stdcall",
"Vale.Interop.X64.arg_reg_stdcall",
"Prims.Nil"... | [] | false | false | false | false | false | let lowstar_gctr128 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr128_t s =
| assert_norm (List.length dom + List.length ([] <: list arg) <= 20);
IX64.wrap_weak_stdcall code_gctr128
dom
(W.mk_prediction code_gctr128 dom [] ((gctr128_lemma s) code_gctr128 IA.win)) | false |
MerkleTree.New.High.Correct.Base.fst | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv | val mt_hashes_lth_inv:
#hsz:pos ->
lv:nat{lv <= 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32} ->
GTot Type0 (decreases (32 - lv)) | val mt_hashes_lth_inv:
#hsz:pos ->
lv:nat{lv <= 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32} ->
GTot Type0 (decreases (32 - lv)) | let rec mt_hashes_lth_inv #hsz lv j fhs =
if lv = 32 then true
else (S.length (S.index fhs lv) == j /\
mt_hashes_lth_inv (lv + 1) (j / 2) fhs) | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 46,
"end_line": 65,
"start_col": 0,
"start_line": 62
} | module MerkleTree.New.High.Correct.Base
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module S = FStar.Seq
module MTS = MerkleTree.Spec
open MerkleTree.New.High
#set-options "--z3rlimit 40 --max_fuel 0 --max_ifuel 0"
/// Sequence helpers
val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
lv: Prims.nat{lv <= 32} ->
j: Prims.nat{j < Prims.pow2 (32 - lv)} ->
fhs: MerkleTree.New.High.hashess{FStar.Seq.Base.length fhs = 32}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial",
""
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Subtraction",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.bool",
"Prims.l_and",
"Prims.eq2",
... | [
"recursion"
] | false | false | false | false | true | let rec mt_hashes_lth_inv #hsz lv j fhs =
| if lv = 32 then true else (S.length (S.index fhs lv) == j /\ mt_hashes_lth_inv (lv + 1) (j / 2) fhs) | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.gctr256_pre | val gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | val gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | let gctr256_pre : (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom =
fun (s:Ghost.erased (Seq.seq nat32))
(c:V.va_code)
(in_b:b128)
(num_bytes:uint64)
(out_b:b128)
(inout_b:b128)
(keys_b:b128)
(ctr_b:b128)
(num_blocks:uint64)
(va_s0:V.va_state) ->
GC.va_req_Gctr_bytes_stdc... | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 169,
"start_col": 0,
"start_line": 155
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.GCTR.dom | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.GCTR.b128",
"Vale.Stdcalls.X64.GCTR.uint64",
"Vale.X64.Decls.va_state",
"Vale.AES.X64.GCTR.va_req_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_256",... | [] | false | false | false | true | false | let gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom =
| fun
(s: Ghost.erased (Seq.seq nat32))
(c: V.va_code)
(in_b: b128)
(num_bytes: uint64)
(out_b: b128)
(inout_b: b128)
(keys_b: b128)
(ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
->
GC.va_req_Gctr_bytes_stdcall c va_s0 IA.win AES_256 (as_vale_buffer in_b) (UInt64.v num_bytes)
(as_vale... | false |
MerkleTree.New.High.Correct.Base.fst | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_empty | val mt_hashes_lth_inv_empty:
#hsz:pos ->
lv:nat{lv <= 32} ->
Lemma (requires True)
(ensures mt_hashes_lth_inv lv 0 (empty_hashes #hsz 32))
(decreases (32 - lv)) | val mt_hashes_lth_inv_empty:
#hsz:pos ->
lv:nat{lv <= 32} ->
Lemma (requires True)
(ensures mt_hashes_lth_inv lv 0 (empty_hashes #hsz 32))
(decreases (32 - lv)) | let rec mt_hashes_lth_inv_empty #hsz lv =
if lv = 32 then ()
else mt_hashes_lth_inv_empty #hsz (lv + 1) | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 44,
"end_line": 75,
"start_col": 0,
"start_line": 73
} | module MerkleTree.New.High.Correct.Base
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module S = FStar.Seq
module MTS = MerkleTree.Spec
open MerkleTree.New.High
#set-options "--z3rlimit 40 --max_fuel 0 --max_ifuel 0"
/// Sequence helpers
val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | lv: Prims.nat{lv <= 32}
-> FStar.Pervasives.Lemma
(ensures
MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv lv
0
(MerkleTree.New.High.Correct.Base.empty_hashes 32)) (decreases 32 - lv) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_empty",
"Prims.op_Addition",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec mt_hashes_lth_inv_empty #hsz lv =
| if lv = 32 then () else mt_hashes_lth_inv_empty #hsz (lv + 1) | false |
MerkleTree.New.High.Correct.Base.fst | MerkleTree.New.High.Correct.Base.merge_hs_empty | val merge_hs_empty:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
len:nat ->
Lemma (S.equal (merge_hs #_ #f (empty_hashes #hsz len) (empty_hashes #hsz len))
(empty_hashes #hsz len)) | val merge_hs_empty:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
len:nat ->
Lemma (S.equal (merge_hs #_ #f (empty_hashes #hsz len) (empty_hashes #hsz len))
(empty_hashes #hsz len)) | let rec merge_hs_empty #hsz #f len =
if len = 0 then ()
else (empty_hashes_head #hsz len;
empty_hashes_tail #hsz len;
assert (S.equal (S.append #(hash #hsz) S.empty S.empty)
(S.empty #(hash #hsz)));
assert (S.equal (merge_hs #_ #f (empty_hashes len) (empty_hashes len))
... | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 38,
"end_line": 173,
"start_col": 0,
"start_line": 163
} | module MerkleTree.New.High.Correct.Base
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module S = FStar.Seq
module MTS = MerkleTree.Spec
open MerkleTree.New.High
#set-options "--z3rlimit 40 --max_fuel 0 --max_ifuel 0"
/// Sequence helpers
val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | len: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (MerkleTree.New.High.Correct.Base.merge_hs (MerkleTree.New.High.Correct.Base.empty_hashes
len)
(MerkleTree.New.High.Correct.Base.empty_hashes len))
(MerkleTree.New.High.Correct.Base.empty_hashes len)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.merge_hs_empty",
"Prims.op_Subtraction",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correct... | [
"recursion"
] | false | false | true | false | false | let rec merge_hs_empty #hsz #f len =
| if len = 0
then ()
else
(empty_hashes_head #hsz len;
empty_hashes_tail #hsz len;
assert (S.equal (S.append #(hash #hsz) S.empty S.empty) (S.empty #(hash #hsz)));
assert (S.equal (merge_hs #_ #f (empty_hashes len) (empty_hashes len))
(S.cons S.empty (merge_hs #_ #f (empty_hashes (len - 1)) (empty... | false |
Vale.Stdcalls.X64.GCTR.fst | Vale.Stdcalls.X64.GCTR.gctr128_post | val gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom | val gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom | let gctr128_post : (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom =
fun (s:Ghost.erased (Seq.seq nat32))
(c:V.va_code)
(in_b:b128)
(num_bytes:uint64)
(out_b:b128)
(inout_b:b128)
(keys_b:b128)
(ctr_b:b128)
(num_blocks:uint64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.... | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 86,
"start_col": 0,
"start_line": 70
} | module Vale.Stdcalls.X64.GCTR
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LS... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Int... | [
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCTR",
"short_module": "GC"
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.GCTR.dom | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.GCTR.b128",
"Vale.Stdcalls.X64.GCTR.uint64",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_fuel",
"Vale.AES.X64.GCTR.va_ens_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Val... | [] | false | false | false | true | false | let gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom =
| fun
(s: Ghost.erased (Seq.seq nat32))
(c: V.va_code)
(in_b: b128)
(num_bytes: uint64)
(out_b: b128)
(inout_b: b128)
(keys_b: b128)
(ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
(va_s1: V.va_state)
(f: V.va_fuel)
->
GC.va_ens_Gctr_bytes_stdcall c va_s0 IA.win AES_128 (as_vale_buffer ... | false |
Hacl.Spec.K256.Scalar.fst | Hacl.Spec.K256.Scalar.mod_lseq | val mod_lseq: a:lseq uint64 8 -> qelem_lseq | val mod_lseq: a:lseq uint64 8 -> qelem_lseq | let mod_lseq a =
let c0, r = mod_lseq_before_final a in
let (t0,t1,t2,t3) = make_pow2_256_minus_order_k256 () in
let tmp = create4 t0 t1 t2 t3 in
let c1, out = SB.bn_add r tmp in
let mask = u64 0 -. (c0 +. c1) in
map2 (BB.mask_select mask) out r | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 178,
"start_col": 0,
"start_line": 170
} | module Hacl.Spec.K256.Scalar
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module SB = Hacl.Spec.Bignum
module BB = Hacl.Spec.Bignum.Base
module S = Spec.K256
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let qelem4 = uint64 & uint64 & uint64 &... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 8 -> Hacl.Spec.K256.Scalar.qelem_lseq | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Spec.Bignum.Base.carry",
"Lib.IntTypes.U64",
"Hacl.Spec.K256.Scalar.qelem_lseq",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.map2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.IntTypes.int_t",
"Lib.Int... | [] | false | false | false | false | false | let mod_lseq a =
| let c0, r = mod_lseq_before_final a in
let t0, t1, t2, t3 = make_pow2_256_minus_order_k256 () in
let tmp = create4 t0 t1 t2 t3 in
let c1, out = SB.bn_add r tmp in
let mask = u64 0 -. (c0 +. c1) in
map2 (BB.mask_select mask) out r | false |
MerkleTree.New.High.Correct.Base.fst | MerkleTree.New.High.Correct.Base.mt_hashes_next_rel | val mt_hashes_next_rel:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
GTot Type0 | val mt_hashes_next_rel:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
GTot Type0 | let mt_hashes_next_rel #hsz #f j hs nhs =
forall (i:nat{i < j / 2}).
S.index nhs i ==
f (S.index hs (op_Multiply 2 i))
(S.index hs (op_Multiply 2 i + 1)) | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 45,
"end_line": 87,
"start_col": 0,
"start_line": 83
} | module MerkleTree.New.High.Correct.Base
open FStar.Classical
open FStar.Ghost
open FStar.Seq
module S = FStar.Seq
module MTS = MerkleTree.Spec
open MerkleTree.New.High
#set-options "--z3rlimit 40 --max_fuel 0 --max_ifuel 0"
/// Sequence helpers
val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": false,
"full_module": "MerkleTree.New.High",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
j: Prims.nat ->
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs = j} ->
nhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length nhs = j / 2}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.int",
"Prims.op_Division",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.eq2",
"Spec.Hash.Definitions.bytes",
... | [] | false | false | false | false | true | let mt_hashes_next_rel #hsz #f j hs nhs =
| forall (i: nat{i < j / 2}).
S.index nhs i == f (S.index hs (op_Multiply 2 i)) (S.index hs (op_Multiply 2 i + 1)) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.