effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | [
{
"abbrev": true,
"full_module": "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... | false | let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret}) | let t128_no_mod = | false | null | false | TD_Buffer TUInt8 TUInt128 ({ modified = false; strict_disjointness = false; taint = MS.Secret }) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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"
] | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val t128_no_mod : Vale.Interop.Base.td | [] | Vale.Stdcalls.X64.GCTR.t128_no_mod | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.Base.td | {
"end_col": 106,
"end_line": 40,
"start_col": 18,
"start_line": 40
} | |
Prims.Tot | [
{
"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... | false | let tuint64 = TD_Base TUInt64 | let tuint64 = | false | null | false | TD_Base TUInt64 | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"Vale.Interop.Base.TD_Base",
"Vale.Arch.HeapTypes_s.TUInt64"
] | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val tuint64 : Vale.Interop.Base.td | [] | Vale.Stdcalls.X64.GCTR.tuint64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.Base.td | {
"end_col": 29,
"end_line": 42,
"start_col": 14,
"start_line": 42
} | |
Prims.Tot | [
{
"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... | false | let code_gctr256 = GC.va_code_Gctr_bytes_stdcall IA.win AES_256 | let code_gctr256 = | false | null | false | GC.va_code_Gctr_bytes_stdcall IA.win AES_256 | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"Vale.AES.X64.GCTR.va_code_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_256"
] | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val code_gctr256 : Vale.X64.Decls.va_code | [] | Vale.Stdcalls.X64.GCTR.code_gctr256 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Decls.va_code | {
"end_col": 63,
"end_line": 234,
"start_col": 19,
"start_line": 234
} | |
Prims.Tot | [
{
"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... | false | let code_gctr128 = GC.va_code_Gctr_bytes_stdcall IA.win AES_128 | let code_gctr128 = | false | null | false | GC.va_code_Gctr_bytes_stdcall IA.win AES_128 | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"Vale.AES.X64.GCTR.va_code_Gctr_bytes_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_128"
] | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val code_gctr128 : Vale.X64.Decls.va_code | [] | Vale.Stdcalls.X64.GCTR.code_gctr128 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Decls.va_code | {
"end_col": 63,
"end_line": 131,
"start_col": 19,
"start_line": 131
} | |
Prims.Tot | [
{
"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... | false | 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) | let gctr128_bytes = | false | null | false | as_normal_t #(s: Ghost.erased (Seq.seq nat32) -> lowstar_gctr128_t s)
(fun (s: Ghost.erased (Seq.seq nat32)) -> lowstar_gctr128 s) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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"
] | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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) | [] | Vale.Stdcalls.X64.GCTR.gctr128_bytes | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 134,
"end_line": 258,
"start_col": 4,
"start_line": 258
} | |
Prims.Tot | [
{
"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... | false | let gctr256_bytes //: normal ((s:Ghost.erased (Seq.seq nat32)) -> lowstar_gctr256_t s)
= as_normal_t #((s:Ghost.erased (Seq.seq nat32)) -> lowstar_gctr256_t s) (fun (s:Ghost.erased (Seq.seq nat32)) -> lowstar_gctr256 s) | let gctr256_bytes = | false | null | false | as_normal_t #(s: Ghost.erased (Seq.seq nat32) -> lowstar_gctr256_t s)
(fun (s: Ghost.erased (Seq.seq nat32)) -> lowstar_gctr256 s) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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_gctr256_t",
"Vale.Stdcalls.X64.GCTR.lowstar_gctr256"
] | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr256_bytes : Vale.Interop.Base.normal (s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr256_t s) | [] | Vale.Stdcalls.X64.GCTR.gctr256_bytes | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.Base.normal (s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr256_t s) | {
"end_col": 134,
"end_line": 262,
"start_col": 4,
"start_line": 262
} | |
Prims.Tot | val as_normal_t (#a: Type) (x: a) : normal a | [
{
"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... | false | let as_normal_t (#a:Type) (x:a) : normal a = x | val as_normal_t (#a: Type) (x: a) : normal a
let as_normal_t (#a: Type) (x: a) : normal a = | false | null | false | x | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"Vale.Interop.Base.normal"
] | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val as_normal_t (#a: Type) (x: a) : normal a | [] | Vale.Stdcalls.X64.GCTR.as_normal_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: a -> Vale.Interop.Base.normal a | {
"end_col": 46,
"end_line": 33,
"start_col": 45,
"start_line": 33
} |
Prims.Tot | val as_t (#a: Type) (x: normal a) : a | [
{
"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... | false | let as_t (#a:Type) (x:normal a) : a = x | val as_t (#a: Type) (x: normal a) : a
let as_t (#a: Type) (x: normal a) : a = | false | null | false | x | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"Vale.Interop.Base.normal"
] | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val as_t (#a: Type) (x: normal a) : a | [] | Vale.Stdcalls.X64.GCTR.as_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Interop.Base.normal a -> a | {
"end_col": 39,
"end_line": 31,
"start_col": 38,
"start_line": 31
} |
Prims.Tot | val dom:dom: list td {List.length dom <= 20} | [
{
"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... | false | 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 | val dom:dom: list td {List.length dom <= 20}
let dom:dom: list td {List.length dom <= 20} = | false | null | false | 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 | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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... | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val dom:dom: list td {List.length dom <= 20} | [] | Vale.Stdcalls.X64.GCTR.dom | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dom: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length dom <= 20} | {
"end_col": 3,
"end_line": 48,
"start_col": 43,
"start_line": 45
} |
Prims.Tot | [
{
"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... | false | 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)) | let lowstar_gctr128_t (s: Ghost.erased (Seq.seq nat32)) = | false | null | false | 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)) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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... | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lowstar_gctr128_t : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> Type0 | [] | Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> Type0 | {
"end_col": 81,
"end_line": 142,
"start_col": 2,
"start_line": 135
} | |
Prims.Tot | val lowstar_gctr256 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr256_t s | [
{
"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... | 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)) | 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 = | false | null | false | 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)) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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"... | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lowstar_gctr256 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr256_t s | [] | Vale.Stdcalls.X64.GCTR.lowstar_gctr256 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr256_t s | {
"end_col": 81,
"end_line": 254,
"start_col": 2,
"start_line": 250
} |
Prims.Tot | [
{
"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... | false | let lowstar_gctr256_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_gctr256
dom
[]
_
_
(W.mk_prediction code_gctr256 dom [] ((gctr256_lemma s) code_gctr256 IA.win)) | let lowstar_gctr256_t (s: Ghost.erased (Seq.seq nat32)) = | false | null | false | assert_norm (List.length dom + List.length ([] <: list arg) <= 20);
IX64.as_lowstar_sig_t_weak_stdcall code_gctr256
dom
[]
_
_
(W.mk_prediction code_gctr256 dom [] ((gctr256_lemma s) code_gctr256 IA.win)) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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_gctr256",
"Vale.Stdcalls.X64.GCTR.dom",
"Prims.Nil",
"Vale.Interop.Base.arg",
"Vale.AsLowStar.Wrapper.pre_rel_generic",
"Vale.Interop.X64.max_stdcall... | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lowstar_gctr256_t : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> Type0 | [] | Vale.Stdcalls.X64.GCTR.lowstar_gctr256_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> Type0 | {
"end_col": 81,
"end_line": 245,
"start_col": 2,
"start_line": 238
} | |
Prims.Tot | val lowstar_gctr128 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr128_t s | [
{
"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... | 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)) | 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 = | false | null | false | 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)) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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"... | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lowstar_gctr128 (s: Ghost.erased (Seq.seq nat32)) : lowstar_gctr128_t s | [] | Vale.Stdcalls.X64.GCTR.lowstar_gctr128 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.Stdcalls.X64.GCTR.lowstar_gctr128_t s | {
"end_col": 81,
"end_line": 151,
"start_col": 2,
"start_line": 147
} |
Prims.Tot | val gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | [
{
"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... | 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_stdc... | val gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom
let gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom = | false | null | false | 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... | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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",... | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr128_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | [] | Vale.Stdcalls.X64.GCTR.gctr128_pre | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.GCTR.dom | {
"end_col": 69,
"end_line": 66,
"start_col": 2,
"start_line": 53
} |
Prims.Tot | val gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | [
{
"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... | 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_stdc... | val gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom
let gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom = | false | null | false | 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... | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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",... | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr256_pre: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_pre dom | [] | Vale.Stdcalls.X64.GCTR.gctr256_pre | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.GCTR.dom | {
"end_col": 69,
"end_line": 169,
"start_col": 2,
"start_line": 156
} |
Prims.Tot | val gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom | [
{
"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... | 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.... | val gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom
let gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom = | false | null | false | 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 ... | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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... | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr128_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom | [] | Vale.Stdcalls.X64.GCTR.gctr128_post | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.GCTR.dom | {
"end_col": 77,
"end_line": 86,
"start_col": 2,
"start_line": 71
} |
Prims.Tot | val gctr256_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom | [
{
"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... | false | let gctr256_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.... | val gctr256_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom
let gctr256_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom = | false | null | false | 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_256 (as_vale_buffer ... | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"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... | [] | 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... | false | true | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr256_post: (Ghost.erased (Seq.seq nat32)) -> VSig.vale_post dom | [] | Vale.Stdcalls.X64.GCTR.gctr256_post | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Words_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.GCTR.dom | {
"end_col": 77,
"end_line": 189,
"start_col": 2,
"start_line": 174
} |
Prims.Tot | [
{
"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... | false | let gctr128_lemma (s:Ghost.erased (Seq.seq nat32)) = as_t #(VSig.vale_sig_stdcall (gctr128_pre s) (gctr128_post s)) (gctr128_lemma' s) | let gctr128_lemma (s: Ghost.erased (Seq.seq nat32)) = | false | null | false | as_t #(VSig.vale_sig_stdcall (gctr128_pre s) (gctr128_post s)) (gctr128_lemma' s) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Stdcalls.X64.GCTR.as_t",
"Vale.AsLowStar.ValeSig.vale_sig_stdcall",
"Vale.Stdcalls.X64.GCTR.dom",
"Vale.Stdcalls.X64.GCTR.gctr128_pre",
"Vale.Stdcalls.X64.GCTR.gctr128_post",
"Vale.Stdcalls.X64.GCTR.gctr128_lemma'"
] | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr128_lemma : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCTR.gctr128_pre s)
(Vale.Stdcalls.X64.GCTR.gctr128_post s) | [] | Vale.Stdcalls.X64.GCTR.gctr128_lemma | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCTR.gctr128_pre s)
(Vale.Stdcalls.X64.GCTR.gctr128_post s) | {
"end_col": 135,
"end_line": 128,
"start_col": 53,
"start_line": 128
} | |
Prims.Tot | [
{
"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... | false | let gctr256_lemma (s:Ghost.erased (Seq.seq nat32)) = as_t #(VSig.vale_sig_stdcall (gctr256_pre s) (gctr256_post s)) (gctr256_lemma' s) | let gctr256_lemma (s: Ghost.erased (Seq.seq nat32)) = | false | null | false | as_t #(VSig.vale_sig_stdcall (gctr256_pre s) (gctr256_post s)) (gctr256_lemma' s) | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [
"total"
] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Stdcalls.X64.GCTR.as_t",
"Vale.AsLowStar.ValeSig.vale_sig_stdcall",
"Vale.Stdcalls.X64.GCTR.dom",
"Vale.Stdcalls.X64.GCTR.gctr256_pre",
"Vale.Stdcalls.X64.GCTR.gctr256_post",
"Vale.Stdcalls.X64.GCTR.gctr256_lemma'"
] | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr256_lemma : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCTR.gctr256_pre s)
(Vale.Stdcalls.X64.GCTR.gctr256_post s) | [] | Vale.Stdcalls.X64.GCTR.gctr256_lemma | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32)
-> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCTR.gctr256_pre s)
(Vale.Stdcalls.X64.GCTR.gctr256_post s) | {
"end_col": 135,
"end_line": 231,
"start_col": 53,
"start_line": 231
} | |
Prims.Ghost | val gctr128_lemma'
(s: Ghost.erased (Seq.seq nat32))
(code: V.va_code)
(_win: bool)
(in_b: b128)
(num_bytes: uint64)
(out_b inout_b keys_b ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires gctr128_pre s code in_b nu... | [
{
"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... | false | let gctr128_lemma'
(s:Ghost.erased (Seq.seq nat32))
(code:V.va_code)
(_win:bool)
(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)
: Ghost (V.va_state & V.va_fuel)
(requires
gctr128_pre s ... | val gctr128_lemma'
(s: Ghost.erased (Seq.seq nat32))
(code: V.va_code)
(_win: bool)
(in_b: b128)
(num_bytes: uint64)
(out_b inout_b keys_b ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires gctr128_pre s code in_b nu... | false | null | false | let va_s1, f =
GC.va_lemma_Gctr_bytes_stdcall code va_s0 IA.win AES_128 (as_vale_buffer in_b)
(UInt64.v num_bytes) (as_vale_buffer out_b) (as_vale_buffer inout_b) (as_vale_buffer keys_b)
(as_vale_buffer ctr_b) (UInt64.v num_blocks) (Ghost.reveal s)
in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TU... | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_code",
"Prims.bool",
"Vale.Stdcalls.X64.GCTR.b128",
"Vale.Stdcalls.X64.GCTR.uint64",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Vale.AsLowStar.M... | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr128_lemma'
(s: Ghost.erased (Seq.seq nat32))
(code: V.va_code)
(_win: bool)
(in_b: b128)
(num_bytes: uint64)
(out_b inout_b keys_b ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires gctr128_pre s code in_b nu... | [] | Vale.Stdcalls.X64.GCTR.gctr128_lemma' | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) ->
code: Vale.X64.Decls.va_code ->
_win: Prims.bool ->
in_b: Vale.Stdcalls.X64.GCTR.b128 ->
num_bytes: Vale.Stdcalls.X64.GCTR.uint64 ->
out_b: Vale.Stdcalls.X64.GCTR.b128 ->
inout_b: Vale.Stdcalls.X64.GCTR.b128 ->
keys_b:... | {
"end_col": 13,
"end_line": 125,
"start_col": 5,
"start_line": 115
} |
Prims.Ghost | val gctr256_lemma'
(s: Ghost.erased (Seq.seq nat32))
(code: V.va_code)
(_win: bool)
(in_b: b128)
(num_bytes: uint64)
(out_b inout_b keys_b ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires gctr256_pre s code in_b nu... | [
{
"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... | false | let gctr256_lemma'
(s:Ghost.erased (Seq.seq nat32))
(code:V.va_code)
(_win:bool)
(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)
: Ghost (V.va_state & V.va_fuel)
(requires
gctr256_pre s ... | val gctr256_lemma'
(s: Ghost.erased (Seq.seq nat32))
(code: V.va_code)
(_win: bool)
(in_b: b128)
(num_bytes: uint64)
(out_b inout_b keys_b ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires gctr256_pre s code in_b nu... | false | null | false | let va_s1, f =
GC.va_lemma_Gctr_bytes_stdcall code va_s0 IA.win AES_256 (as_vale_buffer in_b)
(UInt64.v num_bytes) (as_vale_buffer out_b) (as_vale_buffer inout_b) (as_vale_buffer keys_b)
(as_vale_buffer ctr_b) (UInt64.v num_blocks) (Ghost.reveal s)
in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TU... | {
"checked_file": "Vale.Stdcalls.X64.GCTR.fst.checked",
"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... | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_code",
"Prims.bool",
"Vale.Stdcalls.X64.GCTR.b128",
"Vale.Stdcalls.X64.GCTR.uint64",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Vale.AsLowStar.M... | [] | 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... | false | false | Vale.Stdcalls.X64.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gctr256_lemma'
(s: Ghost.erased (Seq.seq nat32))
(code: V.va_code)
(_win: bool)
(in_b: b128)
(num_bytes: uint64)
(out_b inout_b keys_b ctr_b: b128)
(num_blocks: uint64)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires gctr256_pre s code in_b nu... | [] | Vale.Stdcalls.X64.GCTR.gctr256_lemma' | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) ->
code: Vale.X64.Decls.va_code ->
_win: Prims.bool ->
in_b: Vale.Stdcalls.X64.GCTR.b128 ->
num_bytes: Vale.Stdcalls.X64.GCTR.uint64 ->
out_b: Vale.Stdcalls.X64.GCTR.b128 ->
inout_b: Vale.Stdcalls.X64.GCTR.b128 ->
keys_b:... | {
"end_col": 13,
"end_line": 228,
"start_col": 5,
"start_line": 218
} |
FStar.Pervasives.Lemma | val big_or'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_or' f [] == False) | [
{
"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",
... | false | let big_or'_nil (#a:Type) (f:a -> Type)
= assert (big_or' f [] == False) by (T.compute()) | val big_or'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_or' f [] == False)
let big_or'_nil (#a: Type) (f: (a -> Type)) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (big_or' f [] == False)
(fun _ ->
();
(T.compute ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val big_or'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_or' f [] == False) | [] | FStar.BigOps.big_or'_nil | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> Type0) -> FStar.Pervasives.Lemma (ensures FStar.BigOps.big_or' f [] == Prims.l_False) | {
"end_col": 51,
"end_line": 52,
"start_col": 4,
"start_line": 52
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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",
... | 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 | 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) = | false | null | true | match l with
| [] ->
big_or'_nil f;
()
| hd :: tl ->
big_or'_cons f hd tl;
big_or'_exists f tl | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"Prims.unit",
"FStar.BigOps.big_or'_nil",
"FStar.BigOps.big_or'_exists",
"FStar.BigOps.big_or'_cons"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val big_or'_exists (#a: Type) (f: (a -> Type)) (l: list a)
: Lemma (big_or' f l <==> (exists x. L.memP x l /\ f x)) | [
"recursion"
] | FStar.BigOps.big_or'_exists | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 57,
"end_line": 65,
"start_col": 4,
"start_line": 63
} |
FStar.Pervasives.Lemma | val big_and'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_and' f l) `subtype_of` unit) | [
{
"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",
... | 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 | 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) = | false | null | true | match l with
| [] -> big_and'_nil f
| hd :: tl -> big_and'_cons f hd tl | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"FStar.BigOps.big_and'_nil",
"FStar.BigOps.big_and'_cons",
"Prims.unit"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val big_and'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_and' f l) `subtype_of` unit) | [] | FStar.BigOps.big_and'_prop | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.big_and' f l) Prims.unit) | {
"end_col": 37,
"end_line": 43,
"start_col": 4,
"start_line": 41
} |
FStar.Pervasives.Lemma | val pairwise_or'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_or' f [] == False) | [
{
"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",
... | false | let pairwise_or'_nil (#a:Type) (f:a -> a -> Type0)
= assert (pairwise_or' f [] == False) by (T.compute()) | 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)) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (pairwise_or' f [] == False)
(fun _ ->
();
(T.compute ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pairwise_or'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_or' f [] == False) | [] | FStar.BigOps.pairwise_or'_nil | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> _: a -> Type0)
-> FStar.Pervasives.Lemma (ensures FStar.BigOps.pairwise_or' f [] == Prims.l_False) | {
"end_col": 56,
"end_line": 108,
"start_col": 4,
"start_line": 108
} |
FStar.Pervasives.Lemma | val big_and'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_and' f [] == True) | [
{
"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",
... | false | let big_and'_nil (#a:Type) (f:a -> Type)
= assert (big_and' f [] == True) by (T.compute()) | val big_and'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_and' f [] == True)
let big_and'_nil (#a: Type) (f: (a -> Type)) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (big_and' f [] == True)
(fun _ ->
();
(T.compute ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val big_and'_nil (#a: Type) (f: (a -> Type)) : Lemma (big_and' f [] == True) | [] | FStar.BigOps.big_and'_nil | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> Type0) -> FStar.Pervasives.Lemma (ensures FStar.BigOps.big_and' f [] == Prims.l_True) | {
"end_col": 51,
"end_line": 35,
"start_col": 4,
"start_line": 35
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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",
... | false | 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()) | 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) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (pairwise_and' f (hd :: tl) ==
(big_and' (f hd) tl /\ pairwise_and' f tl))
(fun _ ->
();
(T.trefl ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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)) | [] | FStar.BigOps.pairwise_and'_cons | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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) | {
"end_col": 22,
"end_line": 73,
"start_col": 4,
"start_line": 72
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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",
... | false | 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()) | 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) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (big_and' f (hd :: tl) == (f hd /\ big_and' f tl))
(fun _ ->
();
(T.compute ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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)) | [] | FStar.BigOps.big_and'_cons | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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) | {
"end_col": 78,
"end_line": 38,
"start_col": 4,
"start_line": 38
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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",
... | false | 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()) | 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) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (big_or' f (hd :: tl) == (f hd \/ big_or' f tl))
(fun _ ->
();
(T.compute ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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)) | [] | FStar.BigOps.big_or'_cons | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 76,
"end_line": 55,
"start_col": 4,
"start_line": 55
} |
FStar.Pervasives.Lemma | val big_or'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_or' f l) `subtype_of` unit) | [
{
"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",
... | 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 | 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) = | false | null | true | match l with
| [] -> big_or'_nil f
| hd :: tl -> big_or'_cons f hd tl | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"FStar.BigOps.big_or'_nil",
"FStar.BigOps.big_or'_cons",
"Prims.unit"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val big_or'_prop (#a: Type) (f: (a -> Type)) (l: list a) : Lemma ((big_or' f l) `subtype_of` unit) | [] | FStar.BigOps.big_or'_prop | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.big_or' f l) Prims.unit) | {
"end_col": 36,
"end_line": 60,
"start_col": 4,
"start_line": 58
} |
FStar.Pervasives.Lemma | val pairwise_and'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_and' f [] == True) | [
{
"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",
... | false | let pairwise_and'_nil (#a:Type) (f:a -> a -> Type0)
= assert (pairwise_and' f [] == True) by (T.compute()) | 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)) = | false | null | true | FStar.Tactics.Effect.assert_by_tactic (pairwise_and' f [] == True)
(fun _ ->
();
(T.compute ())) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pairwise_and'_nil (#a: Type) (f: (a -> a -> Type0)) : Lemma (pairwise_and' f [] == True) | [] | FStar.BigOps.pairwise_and'_nil | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> _: a -> Type0)
-> FStar.Pervasives.Lemma (ensures FStar.BigOps.pairwise_and' f [] == Prims.l_True) | {
"end_col": 56,
"end_line": 69,
"start_col": 4,
"start_line": 69
} |
FStar.Pervasives.Lemma | val pairwise_or'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_or' f l) `subtype_of` unit) | [
{
"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",
... | 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 | 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) = | false | null | true | match l with
| [] -> pairwise_or'_nil f
| hd :: tl -> pairwise_or'_cons f hd tl | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"FStar.BigOps.pairwise_or'_nil",
"FStar.BigOps.pairwise_or'_cons",
"Prims.unit"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pairwise_or'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_or' f l) `subtype_of` unit) | [] | FStar.BigOps.pairwise_or'_prop | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.pairwise_or' f l) Prims.unit) | {
"end_col": 41,
"end_line": 116,
"start_col": 4,
"start_line": 114
} |
FStar.Pervasives.Lemma | 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))) | [
{
"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",
... | 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 | 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) = | false | null | true | 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 | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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))) | [
"recursion"
] | FStar.BigOps.pairwise_or'_exists | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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
)) | {
"end_col": 30,
"end_line": 124,
"start_col": 4,
"start_line": 119
} |
FStar.Pervasives.Lemma | val pairwise_and'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_and' f l) `subtype_of` unit) | [
{
"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",
... | 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 | 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) = | false | null | true | match l with
| [] -> pairwise_and'_nil f
| hd :: tl -> pairwise_and'_cons f hd tl | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"FStar.BigOps.pairwise_and'_nil",
"FStar.BigOps.pairwise_and'_cons",
"Prims.unit"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pairwise_and'_prop (#a: Type) (f: (a -> a -> Type)) (l: list a)
: Lemma ((pairwise_and' f l) `subtype_of` unit) | [] | FStar.BigOps.pairwise_and'_prop | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> _: a -> Type0) -> l: Prims.list a
-> FStar.Pervasives.Lemma (ensures Prims.subtype_of (FStar.BigOps.pairwise_and' f l) Prims.unit) | {
"end_col": 42,
"end_line": 78,
"start_col": 4,
"start_line": 76
} |
FStar.Pervasives.Lemma | 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))) | [
{
"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",
... | 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 | 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... | false | null | true | 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 | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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))) | [
"recursion"
] | FStar.BigOps.pairwise_and'_forall_no_repeats | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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 /\ ... | {
"end_col": 31,
"end_line": 104,
"start_col": 4,
"start_line": 99
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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",
... | 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 | 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) = | false | null | true | match l with
| [] ->
big_and'_nil f;
()
| hd :: tl ->
big_and'_cons f hd tl;
big_and'_forall f tl | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"Prims.unit",
"FStar.BigOps.big_and'_nil",
"FStar.BigOps.big_and'_forall",
"FStar.BigOps.big_and'_cons"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val big_and'_forall (#a: Type) (f: (a -> Type)) (l: list a)
: Lemma (big_and' f l <==> (forall x. L.memP x l ==> f x)) | [
"recursion"
] | FStar.BigOps.big_and'_forall | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 59,
"end_line": 48,
"start_col": 4,
"start_line": 46
} |
FStar.Pervasives.Lemma | 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))) | [
{
"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",
... | 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 | 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) = | false | null | true | 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 | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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))) | [
"recursion"
] | FStar.BigOps.pairwise_or'_exists_no_repeats | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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 /\ ~... | {
"end_col": 30,
"end_line": 132,
"start_col": 4,
"start_line": 127
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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",
... | 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)) | 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) = | false | null | true | assert (pairwise_or' f (hd :: tl) == (big_or' (f hd) tl \/ pairwise_or' f tl)) | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"lemma"
] | [
"Prims.list",
"Prims._assert",
"Prims.eq2",
"FStar.BigOps.pairwise_or'",
"Prims.Cons",
"Prims.l_or",
"FStar.BigOps.big_or'",
"Prims.unit"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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)) | [] | FStar.BigOps.pairwise_or'_cons | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 80,
"end_line": 111,
"start_col": 4,
"start_line": 111
} |
FStar.Pervasives.Lemma | 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))) | [
{
"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",
... | 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 | 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) = | false | null | true | 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 | {
"checked_file": "FStar.BigOps.fst.checked",
"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"
} | [
"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"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | false | false | FStar.BigOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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))) | [
"recursion"
] | FStar.BigOps.pairwise_and'_forall | {
"file_name": "ulib/FStar.BigOps.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 31,
"end_line": 96,
"start_col": 4,
"start_line": 91
} |
Prims.Tot | [
{
"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":... | false | let qelem4 = uint64 & uint64 & uint64 & uint64 | let qelem4 = | false | null | false | uint64 & uint64 & uint64 & uint64 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"total"
] | [
"FStar.Pervasives.Native.tuple4",
"Lib.IntTypes.uint64"
] | [] | 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" | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val qelem4 : Type0 | [] | Hacl.Spec.K256.Scalar.qelem4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 46,
"end_line": 17,
"start_col": 13,
"start_line": 17
} | |
Prims.Tot | [
{
"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":... | 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 | let is_qelem_lt_pow2_128_vartime4 (a0, a1, a2, a3: qelem4) : bool = | false | null | false | let open Lib.RawIntTypes in u64_to_UInt64 a2 =. 0uL && u64_to_UInt64 a3 =. 0uL | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val is_qelem_lt_pow2_128_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | [] | Hacl.Spec.K256.Scalar.is_qelem_lt_pow2_128_vartime4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | {
"end_col": 52,
"end_line": 106,
"start_col": 2,
"start_line": 105
} | |
Prims.Tot | [
{
"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":... | 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 | let qas_nat4 (f: qelem4) = | false | null | false | let f0, f1, f2, f3 = f in
v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val qas_nat4 : f: Hacl.Spec.K256.Scalar.qelem4 -> Prims.int | [] | Hacl.Spec.K256.Scalar.qas_nat4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.K256.Scalar.qelem4 -> Prims.int | {
"end_col": 59,
"end_line": 24,
"start_col": 25,
"start_line": 22
} | |
Prims.Tot | [
{
"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":... | 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 | let is_qelem_zero_vartime4 (f0, f1, f2, f3: qelem4) : bool = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val is_qelem_zero_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | [] | Hacl.Spec.K256.Scalar.is_qelem_zero_vartime4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | {
"end_col": 25,
"end_line": 50,
"start_col": 2,
"start_line": 46
} | |
Prims.Tot | [
{
"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":... | 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 | let is_qelem_eq_vartime4 (a0, a1, a2, a3: qelem4) (b0, b1, b2, b3: qelem4) : bool = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val is_qelem_eq_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | [] | Hacl.Spec.K256.Scalar.is_qelem_eq_vartime4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Hacl.Spec.K256.Scalar.qelem4 -> _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | {
"end_col": 38,
"end_line": 100,
"start_col": 2,
"start_line": 96
} | |
Prims.Tot | [
{
"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":... | 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 begin
if u64_to_UInt64 a3 >. 0x7fffffffffffffffuL then false
else begin
if u64_to_UInt64 a2 <. 0xffffffffffffffffuL then true
else begin
... | let is_qelem_le_q_halved_vartime4 (a0, a1, a2, a3: qelem4) : bool = | false | null | false | 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_... | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val is_qelem_le_q_halved_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | [] | Hacl.Spec.K256.Scalar.is_qelem_le_q_halved_vartime4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | {
"end_col": 5,
"end_line": 91,
"start_col": 2,
"start_line": 74
} | |
Prims.Tot | [
{
"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":... | 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 begin
if u64_to_UInt64 a2 <. 0xfffffffffffffffeuL then true
else begin
if u64_to_UInt64 a2 >. 0xfffffffffffffffeuL then false
else begin
if... | let is_qelem_lt_q_vartime4 (a0, a1, a2, a3: qelem4) : bool = | false | null | false | 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... | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val is_qelem_lt_q_vartime4 : _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | [] | Hacl.Spec.K256.Scalar.is_qelem_lt_q_vartime4 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Hacl.Spec.K256.Scalar.qelem4 -> Prims.bool | {
"end_col": 5,
"end_line": 69,
"start_col": 2,
"start_line": 55
} | |
Prims.Tot | [
{
"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":... | false | let qelem_lseq = lseq uint64 4 | let qelem_lseq = | false | null | false | lseq uint64 4 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64"
] | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val qelem_lseq : Type0 | [] | Hacl.Spec.K256.Scalar.qelem_lseq | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 30,
"end_line": 19,
"start_col": 17,
"start_line": 19
} | |
Prims.Tot | val mod_short_lseq: a:qelem_lseq -> qelem_lseq | [
{
"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":... | 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 | val mod_short_lseq: a:qelem_lseq -> qelem_lseq
let mod_short_lseq a = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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... | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_short_lseq: a:qelem_lseq -> qelem_lseq | [] | Hacl.Spec.K256.Scalar.mod_short_lseq | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.K256.Scalar.qelem_lseq -> Hacl.Spec.K256.Scalar.qelem_lseq | {
"end_col": 34,
"end_line": 117,
"start_col": 22,
"start_line": 111
} |
Prims.Pure | val make_pow2_256_minus_order_k256: unit -> Pure qelem4
(requires True)
(ensures fun r -> qas_nat4 r = pow2 256 - S.q) | [
{
"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":... | 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 | 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 () = | false | null | false | [@@ inline_let ]let r = (u64 0x402da1732fc9bebf, u64 0x4551231950b75fc4, u64 0x1, u64 0x0) in
assert_norm (qas_nat4 r = pow2 256 - S.q);
r | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [] | [
"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... | [] | 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 &... | false | false | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val make_pow2_256_minus_order_k256: unit -> Pure qelem4
(requires True)
(ensures fun r -> qas_nat4 r = pow2 256 - S.q) | [] | Hacl.Spec.K256.Scalar.make_pow2_256_minus_order_k256 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> Prims.Pure Hacl.Spec.K256.Scalar.qelem4 | {
"end_col": 3,
"end_line": 41,
"start_col": 2,
"start_line": 33
} |
Prims.Tot | 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 | [
{
"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":... | 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 // 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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... | [] | 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 &... | false | false | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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 | [] | Hacl.Spec.K256.Scalar.mul_pow2_256_minus_q_lseq | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 17,
"end_line": 133,
"start_col": 44,
"start_line": 125
} |
Prims.Tot | val qmul_shift_384 (a b: qelem_lseq) : qelem_lseq | [
{
"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":... | false | let qmul_shift_384 (a b:qelem_lseq) : qelem_lseq =
let l = SB.bn_mul a b in
let res_b = SB.bn_rshift l 6 in
let res_b_padded = create 4 (u64 0) in
let res_b_padded = update_sub res_b_padded 0 2 res_b in
let _, res1_b = SB.bn_add1 res_b_padded (u64 1) in
let flag = l.[5] >>. 63ul in
let mask = u64 0 -. fl... | val qmul_shift_384 (a b: qelem_lseq) : qelem_lseq
let qmul_shift_384 (a b: qelem_lseq) : qelem_lseq = | false | null | false | let l = SB.bn_mul a b in
let res_b = SB.bn_rshift l 6 in
let res_b_padded = create 4 (u64 0) in
let res_b_padded = update_sub res_b_padded 0 2 res_b in
let _, res1_b = SB.bn_add1 res_b_padded (u64 1) in
let flag = l.[ 5 ] >>. 63ul in
let mask = u64 0 -. flag in
map2 (BB.mask_select mask) res1_b res_b_padded | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"total"
] | [
"Hacl.Spec.K256.Scalar.qelem_lseq",
"Hacl.Spec.Bignum.Base.carry",
"Lib.IntTypes.U64",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.map2",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.uint64",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntT... | [] | 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 &... | false | true | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val qmul_shift_384 (a b: qelem_lseq) : qelem_lseq | [] | Hacl.Spec.K256.Scalar.qmul_shift_384 | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.K256.Scalar.qelem_lseq -> b: Hacl.Spec.K256.Scalar.qelem_lseq
-> Hacl.Spec.K256.Scalar.qelem_lseq | {
"end_col": 48,
"end_line": 191,
"start_col": 50,
"start_line": 182
} |
Prims.Tot | 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 | [
{
"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":... | 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 // a * SECP256K1_N_C
SB.bn_add m e | 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 = | false | null | false | let _, m = mul_pow2_256_minus_q_lseq len resLen a in
SB.bn_add m e | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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... | [] | 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 &... | false | false | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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 | [] | Hacl.Spec.K256.Scalar.mul_pow2_256_minus_q_lseq_add | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 15,
"end_line": 143,
"start_col": 50,
"start_line": 141
} |
Prims.Tot | val mod_lseq_before_final: a:lseq uint64 8 -> BB.carry U64 & qelem_lseq | [
{
"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":... | false | let mod_lseq_before_final a =
// Reduce 512 bits into 385.
// m[0..6] = a[0..3] + a[4..7] * SECP256K1_N_C.
// Reduce 385 bits into 258.
// p[0..4] = m[0..3] + m[4..6] * SECP256K1_N_C.
// Reduce 258 bits into 256.
// c, r[0..3] = p[0..3] + p[4] * SECP256K1_N_C.
// Final reduction of r.
// secp256k1_sc... | val mod_lseq_before_final: a:lseq uint64 8 -> BB.carry U64 & qelem_lseq
let mod_lseq_before_final a = | false | null | false | let _, m = mul_pow2_256_minus_q_lseq_add 4 7 (sub a 4 4) (sub a 0 4) in
let _, p = mul_pow2_256_minus_q_lseq_add 3 5 (sub m 4 3) (sub m 0 4) in
mul_pow2_256_minus_q_lseq_add 1 4 (sub p 4 1) (sub p 0 4) | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Spec.Bignum.Base.carry",
"Lib.IntTypes.U64",
"Hacl.Spec.K256.Scalar.mul_pow2_256_minus_q_lseq_add",
"Lib.Sequence.sub",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.K256.Scalar.qelem_lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC"
] | [] | 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 &... | false | false | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_lseq_before_final: a:lseq uint64 8 -> BB.carry U64 & qelem_lseq | [] | Hacl.Spec.K256.Scalar.mod_lseq_before_final | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Lib.Sequence.lseq Lib.IntTypes.uint64 8
-> Hacl.Spec.Bignum.Base.carry Lib.IntTypes.U64 * Hacl.Spec.K256.Scalar.qelem_lseq | {
"end_col": 59,
"end_line": 165,
"start_col": 29,
"start_line": 148
} |
Prims.Tot | val mod_lseq: a:lseq uint64 8 -> qelem_lseq | [
{
"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":... | 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 | val mod_lseq: a:lseq uint64 8 -> qelem_lseq
let mod_lseq a = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.K256.Scalar.fst.checked",
"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... | [
"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... | [] | 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 &... | false | false | Hacl.Spec.K256.Scalar.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_lseq: a:lseq uint64 8 -> qelem_lseq | [] | Hacl.Spec.K256.Scalar.mod_lseq | {
"file_name": "code/k256/Hacl.Spec.K256.Scalar.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Lib.Sequence.lseq Lib.IntTypes.uint64 8 -> Hacl.Spec.K256.Scalar.qelem_lseq | {
"end_col": 34,
"end_line": 178,
"start_col": 16,
"start_line": 170
} |
Prims.Tot | [
{
"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... | false | let matrix_seq #c #m #r (generator: matrix_generator c m r) =
seq_of_matrix (Matrix.init generator) | let matrix_seq #c #m #r (generator: matrix_generator c m r) = | false | null | false | seq_of_matrix (Matrix.init generator) | {
"checked_file": "FStar.Algebra.CommMonoid.Fold.Nested.fst.checked",
"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.Al... | [
"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",
... | [] | (*
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... | false | false | FStar.Algebra.CommMonoid.Fold.Nested.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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... | [] | FStar.Algebra.CommMonoid.Fold.Nested.matrix_seq | {
"file_name": "ulib/FStar.Algebra.CommMonoid.Fold.Nested.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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 ... | {
"end_col": 39,
"end_line": 34,
"start_col": 2,
"start_line": 34
} | |
FStar.Pervasives.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)
... | [
{
"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... | 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 ... | 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)
... | false | null | true | 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)
(#... | {
"checked_file": "FStar.Algebra.CommMonoid.Fold.Nested.fst.checked",
"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.Al... | [
"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... | [] | (*
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... | false | false | FStar.Algebra.CommMonoid.Fold.Nested.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val 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)
... | [] | FStar.Algebra.CommMonoid.Fold.Nested.double_fold_transpose_lemma | {
"file_name": "ulib/FStar.Algebra.CommMonoid.Fold.Nested.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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.... | {
"end_col": 73,
"end_line": 92,
"start_col": 61,
"start_line": 52
} |
Prims.GTot | val mt_root_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs0:hashes #hsz {S.length hs0 > 0} ->
acc:hash #hsz -> actd:bool ->
rt:hash #hsz ->
GTot Type0 | [
{
"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":... | false | let mt_root_inv #_ #f hs0 acc actd rt =
MTS.mt_get_root #_ #f #(log2c (S.length hs0))
(hash_seq_spec_full #_ #f hs0 acc actd) == MTS.HRaw rt | val mt_root_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs0:hashes #hsz {S.length hs0 > 0} ->
acc:hash #hsz -> actd:bool ->
rt:hash #hsz ->
GTot Type0
let mt_root_inv #_ #f hs0 acc actd rt = | false | null | false | MTS.mt_get_root #_ #f #(log2c (S.length hs0)) (hash_seq_spec_full #_ #f hs0 acc actd) == MTS.HRaw rt | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.bool",
"Prims.eq2",
"MerkleTree.Spec.padded_hash",
"MerkleTree.Spec.mt_get_root",
"MerkleTree.New.High.Correct.Base.log2c",
... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val mt_root_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs0:hashes #hsz {S.length hs0 > 0} ->
acc:hash #hsz -> actd:bool ->
rt:hash #hsz ->
GTot Type0 | [] | MerkleTree.New.High.Correct.Base.mt_root_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs0: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs0 > 0} ->
acc: MerkleTree.New.High.hash ->
actd: Prims.bool ->
rt: MerkleTree.New.High.hash
-> Prims.GTot Type0 | {
"end_col": 58,
"end_line": 622,
"start_col": 2,
"start_line": 621
} |
Prims.GTot | val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 <= S.length s2} ->
GTot Type0 | [
{
"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":... | false | let seq_prefix #a s1 s2 =
S.equal s1 (S.slice s2 0 (S.length s1)) | 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 = | false | null | false | S.equal s1 (S.slice s2 0 (S.length s1)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val seq_prefix:
#a:Type -> s1:S.seq a ->
s2:S.seq a{S.length s1 <= S.length s2} ->
GTot Type0 | [] | MerkleTree.New.High.Correct.Base.seq_prefix | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
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 | {
"end_col": 41,
"end_line": 21,
"start_col": 2,
"start_line": 21
} |
Prims.GTot | val mt_olds_inv:
#hsz:pos ->
lv:nat{lv <= 32} ->
i:nat ->
olds:hashess #hsz {S.length olds = 32} ->
GTot Type0 (decreases (32 - lv)) | [
{
"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":... | false | let rec mt_olds_inv #hsz lv i olds =
if lv = 32 then true
else (let ofs = offset_of i in
S.length (S.index olds lv) == ofs /\
mt_olds_inv #hsz (lv + 1) (i / 2) olds) | val mt_olds_inv:
#hsz:pos ->
lv:nat{lv <= 32} ->
i:nat ->
olds:hashess #hsz {S.length olds = 32} ->
GTot Type0 (decreases (32 - lv))
let rec mt_olds_inv #hsz lv i olds = | false | null | false | if lv = 32
then true
else
(let ofs = offset_of i in
S.length (S.index olds lv) == ofs /\ mt_olds_inv #hsz (lv + 1) (i / 2) olds) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.bool",
"Prims.l_and",
"Prims.eq2",
"MerkleTree.New.High.hash",
"FStar.Seq.Base.index",
"Merkle... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_olds_inv:
#hsz:pos ->
lv:nat{lv <= 32} ->
i:nat ->
olds:hashess #hsz {S.length olds = 32} ->
GTot Type0 (decreases (32 - lv)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_olds_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv <= 32} ->
i: Prims.nat ->
olds: MerkleTree.New.High.hashess{FStar.Seq.Base.length olds = 32}
-> Prims.GTot Type0 | {
"end_col": 46,
"end_line": 234,
"start_col": 2,
"start_line": 231
} |
Prims.GTot | val mt_spec:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt /\ MT?.j mt > 0} ->
olds:hashess{S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot (MTS.merkle_tree #hsz (log2c (MT?.j mt))) | [
{
"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":... | false | let mt_spec #hsz mt olds =
hash_seq_spec #_ (mt_base mt olds) | val mt_spec:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt /\ MT?.j mt > 0} ->
olds:hashess{S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot (MTS.merkle_tree #hsz (log2c (MT?.j mt)))
let mt_spec #hsz mt olds = | false | null | false | hash_seq_spec #_ (mt_base mt olds) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.New.High.merkle_tree",
"Prims.l_and",
"MerkleTree.New.High.mt_wf_elts",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.__proj__MT__item__j",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_spec:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt /\ MT?.j mt > 0} ->
olds:hashess{S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot (MTS.merkle_tree #hsz (log2c (MT?.j mt))) | [] | MerkleTree.New.High.Correct.Base.mt_spec | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
mt: MerkleTree.New.High.merkle_tree{MerkleTree.New.High.mt_wf_elts mt /\ MT?.j mt > 0} ->
olds:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length olds = 32 /\
MerkleTree.New.High.Correct.Base.mt_olds_inv 0 (MT?.i mt) olds }
-> Prims.GTot (MerkleTree.Spec.merkle_tree (MerkleTree.New.... | {
"end_col": 36,
"end_line": 640,
"start_col": 2,
"start_line": 640
} |
Prims.GTot | 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 | [
{
"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":... | false | 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)) | 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 = | false | null | false | 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)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"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",
... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | 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 | [] | MerkleTree.New.High.Correct.Base.mt_hashes_next_rel | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
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 | {
"end_col": 45,
"end_line": 87,
"start_col": 2,
"start_line": 84
} |
Prims.GTot | val empty_hashes: (#hsz:pos) -> (len:nat) -> GTot (hs:hashess #hsz {S.length hs = len}) | [
{
"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":... | false | let empty_hashes #hsz len = S.create len S.empty | val empty_hashes: (#hsz:pos) -> (len:nat) -> GTot (hs:hashess #hsz {S.length hs = len})
let empty_hashes #hsz len = | false | null | false | S.create len S.empty | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"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"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val empty_hashes: (#hsz:pos) -> (len:nat) -> GTot (hs:hashess #hsz {S.length hs = len}) | [] | MerkleTree.New.High.Correct.Base.empty_hashes | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | len: Prims.nat -> Prims.GTot (hs: MerkleTree.New.High.hashess{FStar.Seq.Base.length hs = len}) | {
"end_col": 48,
"end_line": 40,
"start_col": 28,
"start_line": 40
} |
Prims.GTot | val mt_inv:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt} ->
olds:hashess{S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot Type0 | [
{
"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":... | false | let mt_inv #hsz mt olds =
let i = MT?.i mt in
let j = MT?.j mt in
let hs = MT?.hs mt in
let rhs = MT?.rhs mt in
let f = MT?.hash_fun mt in
let fhs = merge_hs #hsz #f olds hs in
let rt = MT?.mroot mt in
log2c_bound j 32;
mt_olds_hs_inv #_ #f 0 i j olds hs /\
(if j > 0 && MT?.rhs_ok mt
then (mt_olds... | val mt_inv:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt} ->
olds:hashess{S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot Type0
let mt_inv #hsz mt olds = | false | null | false | let i = MT?.i mt in
let j = MT?.j mt in
let hs = MT?.hs mt in
let rhs = MT?.rhs mt in
let f = MT?.hash_fun mt in
let fhs = merge_hs #hsz #f olds hs in
let rt = MT?.mroot mt in
log2c_bound j 32;
mt_olds_hs_inv #_ #f 0 i j olds hs /\
(if j > 0 && MT?.rhs_ok mt
then
(mt_olds_hs_lth_inv_ok #_ #f 0 i j olds hs;
... | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.New.High.merkle_tree",
"MerkleTree.New.High.mt_wf_elts",
"MerkleTree.New.High.hashess",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correct.Base.mt_olds_inv",
"MerkleTree.New.... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_inv:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt} ->
olds:hashess{S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot Type0 | [] | MerkleTree.New.High.Correct.Base.mt_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
mt: MerkleTree.New.High.merkle_tree{MerkleTree.New.High.mt_wf_elts mt} ->
olds:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length olds = 32 /\
MerkleTree.New.High.Correct.Base.mt_olds_inv 0 (MT?.i mt) olds }
-> Prims.GTot Type0 | {
"end_col": 12,
"end_line": 662,
"start_col": 25,
"start_line": 647
} |
FStar.Pervasives.Lemma | val log2_bound:
n:nat{n > 0} -> c:nat{n < pow2 c} ->
Lemma (log2 n <= c-1) | [
{
"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":... | false | let rec log2_bound n c =
if n = 1 then ()
else log2_bound (n / 2) (c - 1) | val log2_bound:
n:nat{n > 0} -> c:nat{n < pow2 c} ->
Lemma (log2 n <= c-1)
let rec log2_bound n c = | false | null | true | if n = 1 then () else log2_bound (n / 2) (c - 1) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.log2_bound",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val log2_bound:
n:nat{n > 0} -> c:nat{n < pow2 c} ->
Lemma (log2 n <= c-1) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.log2_bound | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | n: Prims.nat{n > 0} -> c: Prims.nat{n < Prims.pow2 c}
-> FStar.Pervasives.Lemma (ensures MerkleTree.New.High.Correct.Base.log2 n <= c - 1) | {
"end_col": 33,
"end_line": 293,
"start_col": 2,
"start_line": 292
} |
Prims.GTot | val hash_seq_spec:
#hsz:pos ->
hs:hashes #hsz {S.length hs > 0} ->
GTot (MTS.merkle_tree #hsz (log2c (S.length hs))) | [
{
"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":... | false | let hash_seq_spec #hsz hs =
S.append (hash_seq_lift #hsz hs)
(create_pads (pow2 (log2c (S.length hs)) - S.length hs)) | val hash_seq_spec:
#hsz:pos ->
hs:hashes #hsz {S.length hs > 0} ->
GTot (MTS.merkle_tree #hsz (log2c (S.length hs)))
let hash_seq_spec #hsz hs = | false | null | false | S.append (hash_seq_lift #hsz hs) (create_pads (pow2 (log2c (S.length hs)) - S.length hs)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"FStar.Seq.Base.append",
"MerkleTree.Spec.padded_hash",
"MerkleTree.New.High.Correct.Base.hash_seq_lift",
"MerkleTree.New.High.Correct.Base.create_pads",
"Prims.op... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val hash_seq_spec:
#hsz:pos ->
hs:hashes #hsz {S.length hs > 0} ->
GTot (MTS.merkle_tree #hsz (log2c (S.length hs))) | [] | MerkleTree.New.High.Correct.Base.hash_seq_spec | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs > 0}
-> Prims.GTot
(MerkleTree.Spec.merkle_tree (MerkleTree.New.High.Correct.Base.log2c (FStar.Seq.Base.length hs))
) | {
"end_col": 67,
"end_line": 435,
"start_col": 2,
"start_line": 434
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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":... | 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))
... | 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 = | false | null | true | 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... | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"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... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | 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)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.merge_hs_empty | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | 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)) | {
"end_col": 38,
"end_line": 173,
"start_col": 2,
"start_line": 164
} |
Prims.GTot | val create_pads: #hsz:pos -> len:nat -> GTot (pads:MTS.hashes #hsz {S.length pads = len}) | [
{
"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":... | false | let create_pads #hsz len = S.create len (MTS.HPad #hsz) | val create_pads: #hsz:pos -> len:nat -> GTot (pads:MTS.hashes #hsz {S.length pads = len})
let create_pads #hsz len = | false | null | false | S.create len (MTS.HPad #hsz) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"Prims.nat",
"FStar.Seq.Base.create",
"MerkleTree.Spec.padded_hash",
"MerkleTree.Spec.HPad",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val create_pads: #hsz:pos -> len:nat -> GTot (pads:MTS.hashes #hsz {S.length pads = len}) | [] | MerkleTree.New.High.Correct.Base.create_pads | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | len: Prims.nat -> Prims.GTot (pads: MerkleTree.Spec.hashes{FStar.Seq.Base.length pads = len}) | {
"end_col": 55,
"end_line": 427,
"start_col": 27,
"start_line": 427
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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":... | false | let rec mt_hashes_lth_inv_empty #hsz lv =
if lv = 32 then ()
else mt_hashes_lth_inv_empty #hsz (lv + 1) | 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 = | false | null | true | if lv = 32 then () else mt_hashes_lth_inv_empty #hsz (lv + 1) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"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"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | 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)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_empty | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | 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) | {
"end_col": 44,
"end_line": 75,
"start_col": 2,
"start_line": 74
} |
Prims.GTot | val log2: n:nat{n > 0} -> GTot (c:nat{pow2 c <= n && n < pow2 (c+1)}) | [
{
"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":... | false | let rec log2 n =
if n = 1 then 0
else 1 + log2 (n / 2) | val log2: n:nat{n > 0} -> GTot (c:nat{pow2 c <= n && n < pow2 (c+1)})
let rec log2 n = | false | null | false | if n = 1 then 0 else 1 + log2 (n / 2) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"MerkleTree.New.High.Correct.Base.log2",
"Prims.op_Division",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"Prims.op_LessThan"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val log2: n:nat{n > 0} -> GTot (c:nat{pow2 c <= n && n < pow2 (c+1)}) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.log2 | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | n: Prims.nat{n > 0} -> Prims.GTot (c: Prims.nat{Prims.pow2 c <= n && n < Prims.pow2 (c + 1)}) | {
"end_col": 23,
"end_line": 286,
"start_col": 2,
"start_line": 285
} |
Prims.GTot | val log2c:
n:nat ->
GTot (c:nat{c = 0 || (pow2 (c-1) <= n && n < pow2 c)}) | [
{
"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":... | false | let log2c n =
if n = 0 then 0 else (log2 n + 1) | val log2c:
n:nat ->
GTot (c:nat{c = 0 || (pow2 (c-1) <= n && n < pow2 c)})
let log2c n = | false | null | false | if n = 0 then 0 else (log2 n + 1) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"MerkleTree.New.High.Correct.Base.log2",
"Prims.b2t",
"Prims.op_BarBar",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.op_LessThan"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val log2c:
n:nat ->
GTot (c:nat{c = 0 || (pow2 (c-1) <= n && n < pow2 c)}) | [] | MerkleTree.New.High.Correct.Base.log2c | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | n: Prims.nat -> Prims.GTot (c: Prims.nat{c = 0 || Prims.pow2 (c - 1) <= n && n < Prims.pow2 c}) | {
"end_col": 35,
"end_line": 304,
"start_col": 2,
"start_line": 304
} |
FStar.Pervasives.Lemma | val hash_seq_spec_index_raw:
#hsz:pos ->
hs:hashes #hsz {S.length hs > 0} ->
i:nat{i < S.length hs} ->
Lemma (S.index (hash_seq_spec #hsz hs) i == MTS.HRaw #hsz (S.index hs i)) | [
{
"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":... | false | let hash_seq_spec_index_raw #hsz hs i =
hash_seq_lift_index #hsz hs | val hash_seq_spec_index_raw:
#hsz:pos ->
hs:hashes #hsz {S.length hs > 0} ->
i:nat{i < S.length hs} ->
Lemma (S.index (hash_seq_spec #hsz hs) i == MTS.HRaw #hsz (S.index hs i))
let hash_seq_spec_index_raw #hsz hs i = | false | null | true | hash_seq_lift_index #hsz hs | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.nat",
"Prims.op_LessThan",
"MerkleTree.New.High.Correct.Base.hash_seq_lift_index",
"Prims.unit"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val hash_seq_spec_index_raw:
#hsz:pos ->
hs:hashes #hsz {S.length hs > 0} ->
i:nat{i < S.length hs} ->
Lemma (S.index (hash_seq_spec #hsz hs) i == MTS.HRaw #hsz (S.index hs i)) | [] | MerkleTree.New.High.Correct.Base.hash_seq_spec_index_raw | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs > 0} ->
i: Prims.nat{i < FStar.Seq.Base.length hs}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.index (MerkleTree.New.High.Correct.Base.hash_seq_spec hs) i ==
MerkleTree.Spec.HRaw (FStar.Seq.Base.index hs i)) | {
"end_col": 29,
"end_line": 443,
"start_col": 2,
"start_line": 443
} |
FStar.Pervasives.Lemma | val mt_hashes_inv_empty:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
Lemma (requires True)
(ensures (mt_hashes_lth_inv_empty #hsz lv;
mt_hashes_inv #hsz #f lv 0 (empty_hashes #hsz 32)))
(decreases (32 - lv)) | [
{
"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":... | false | let rec mt_hashes_inv_empty #hsz #f lv =
if lv = 31 then ()
else (mt_hashes_lth_inv_empty #hsz (lv + 1);
mt_hashes_inv_empty #_ #f (lv + 1)) | val mt_hashes_inv_empty:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
Lemma (requires True)
(ensures (mt_hashes_lth_inv_empty #hsz lv;
mt_hashes_inv #hsz #f lv 0 (empty_hashes #hsz 32)))
(decreases (32 - lv))
let rec mt_hashes_inv_empty #hsz #f lv = | false | null | true | if lv = 31
then ()
else
(mt_hashes_lth_inv_empty #hsz (lv + 1);
mt_hashes_inv_empty #_ #f (lv + 1)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.mt_hashes_inv_empty",
"Prims.op_Addition",
"Prims.unit",
"MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_empty"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mt_hashes_inv_empty:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
Lemma (requires True)
(ensures (mt_hashes_lth_inv_empty #hsz lv;
mt_hashes_inv #hsz #f lv 0 (empty_hashes #hsz 32)))
(decreases (32 - lv)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_inv_empty | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | lv: Prims.nat{lv < 32}
-> FStar.Pervasives.Lemma
(ensures
([@@ FStar.Pervasives.inline_let ]let _ =
MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_empty lv
in
MerkleTree.New.High.Correct.Base.mt_hashes_inv lv
0
(MerkleTree.New.High.Correct.Base... | {
"end_col": 43,
"end_line": 112,
"start_col": 2,
"start_line": 110
} |
FStar.Pervasives.Lemma | val hash_seq_spec_full_index_raw:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs:hashes #hsz {S.length hs > 0} ->
acc:hash #hsz -> actd:bool -> i:nat{i < S.length hs} ->
Lemma (S.index (hash_seq_spec_full #_ #f hs acc actd) i ==
MTS.HRaw (S.index hs i)) | [
{
"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":... | false | let hash_seq_spec_full_index_raw #hsz #_ hs acc actd i =
hash_seq_spec_index_raw #hsz hs i | val hash_seq_spec_full_index_raw:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs:hashes #hsz {S.length hs > 0} ->
acc:hash #hsz -> actd:bool -> i:nat{i < S.length hs} ->
Lemma (S.index (hash_seq_spec_full #_ #f hs acc actd) i ==
MTS.HRaw (S.index hs i))
let hash_seq_spec_full_index_raw #hsz #_ hs acc actd i = | false | null | true | hash_seq_spec_index_raw #hsz hs i | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.bool",
"Prims.nat",
"Prims.op_LessThan",
"MerkleTree.New.High.Correct.Base.hash_seq_spec_index_raw",
"Prims.unit"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val hash_seq_spec_full_index_raw:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs:hashes #hsz {S.length hs > 0} ->
acc:hash #hsz -> actd:bool -> i:nat{i < S.length hs} ->
Lemma (S.index (hash_seq_spec_full #_ #f hs acc actd) i ==
MTS.HRaw (S.index hs i)) | [] | MerkleTree.New.High.Correct.Base.hash_seq_spec_full_index_raw | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs > 0} ->
acc: MerkleTree.New.High.hash ->
actd: Prims.bool ->
i: Prims.nat{i < FStar.Seq.Base.length hs}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.index (MerkleTree.New.High.Correct.Base.hash_seq_spec_full hs acc actd) i ==
... | {
"end_col": 35,
"end_line": 506,
"start_col": 2,
"start_line": 506
} |
FStar.Pervasives.Lemma | val mt_hashes_inv_log_converted:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 0 && j < pow2 32} ->
fhs:hashess #hsz {S.length fhs = 32 /\ mt_hashes_lth_inv #hsz 0 j fhs} ->
Lemma (requires mt_hashes_inv #_ #f 0 j fhs)
(ensures (log2c_bound j 32;
mt_hashes_lth_inv_log_converted_ #_ #... | [
{
"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":... | false | let mt_hashes_inv_log_converted #_ #f j fhs =
mt_hashes_inv_log_converted_ #_ #f 0 j fhs | val mt_hashes_inv_log_converted:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 0 && j < pow2 32} ->
fhs:hashess #hsz {S.length fhs = 32 /\ mt_hashes_lth_inv #hsz 0 j fhs} ->
Lemma (requires mt_hashes_inv #_ #f 0 j fhs)
(ensures (log2c_bound j 32;
mt_hashes_lth_inv_log_converted_ #_ #... | false | null | true | mt_hashes_inv_log_converted_ #_ #f 0 j fhs | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.pow2",
"MerkleTree.New.High.hashess",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Merkl... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_hashes_inv_log_converted:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 0 && j < pow2 32} ->
fhs:hashess #hsz {S.length fhs = 32 /\ mt_hashes_lth_inv #hsz 0 j fhs} ->
Lemma (requires mt_hashes_inv #_ #f 0 j fhs)
(ensures (log2c_bound j 32;
mt_hashes_lth_inv_log_converted_ #_ #... | [] | MerkleTree.New.High.Correct.Base.mt_hashes_inv_log_converted | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat{j > 0 && j < Prims.pow2 32} ->
fhs:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length fhs = 32 /\
MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv 0 j fhs }
-> FStar.Pervasives.Lemma (requires MerkleTree.New.High.Correct.Base.mt_hashes_inv 0 j fhs)
(ensures
... | {
"end_col": 44,
"end_line": 402,
"start_col": 2,
"start_line": 402
} |
Prims.GTot | val mt_olds_hs_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
i:nat ->
j:nat{i <= j /\ j < pow2 (32 - lv)} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz lv i olds} ->
hs:hashess #hsz {S.length hs = 32 /\ hs_wf_elts #hsz lv hs i j} ->
GTot Type0 | [
{
"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":... | false | let mt_olds_hs_inv #hsz #f lv i j olds hs =
mt_olds_hs_lth_inv_ok #_ #f lv i j olds hs;
mt_hashes_inv #_ #f lv j (merge_hs #_ #f olds hs) | val mt_olds_hs_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
i:nat ->
j:nat{i <= j /\ j < pow2 (32 - lv)} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz lv i olds} ->
hs:hashess #hsz {S.length hs = 32 /\ hs_wf_elts #hsz lv hs i j} ->
GTot Type0
let mt_olds_hs_inv #hsz #f lv i... | false | null | false | mt_olds_hs_lth_inv_ok #_ #f lv i j olds hs;
mt_hashes_inv #_ #f lv j (merge_hs #_ #f olds hs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"Prims.op_Subtraction",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_olds_hs_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
i:nat ->
j:nat{i <= j /\ j < pow2 (32 - lv)} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz lv i olds} ->
hs:hashess #hsz {S.length hs = 32 /\ hs_wf_elts #hsz lv hs i j} ->
GTot Type0 | [] | MerkleTree.New.High.Correct.Base.mt_olds_hs_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv < 32} ->
i: Prims.nat ->
j: Prims.nat{i <= j /\ j < Prims.pow2 (32 - lv)} ->
olds:
MerkleTree.New.High.hashess
{FStar.Seq.Base.length olds = 32 /\ MerkleTree.New.High.Correct.Base.mt_olds_inv lv i olds} ->
hs:
MerkleTree.New.High.hashess
{FStar.Seq.Base.... | {
"end_col": 51,
"end_line": 275,
"start_col": 2,
"start_line": 274
} |
FStar.Pervasives.Lemma | val mt_olds_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
i:nat ->
olds1:hashess #hsz {S.length olds1 = 32} ->
olds2:hashess #hsz {S.length olds2 = 32} ->
Lemma (requires mt_olds_inv #hsz lv i olds1 /\
S.equal (S.slice olds1 lv 32) (S.slice olds2 lv 32))
(ens... | [
{
"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":... | false | let rec mt_olds_inv_equiv #hsz #f lv i olds1 olds2 =
if lv = 32 then ()
else (assert (S.index olds1 lv == S.index olds2 lv);
mt_olds_inv_equiv #_ #f (lv + 1) (i / 2) olds1 olds2) | val mt_olds_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
i:nat ->
olds1:hashess #hsz {S.length olds1 = 32} ->
olds2:hashess #hsz {S.length olds2 = 32} ->
Lemma (requires mt_olds_inv #hsz lv i olds1 /\
S.equal (S.slice olds1 lv 32) (S.slice olds2 lv 32))
(ens... | false | null | true | if lv = 32
then ()
else
(assert (S.index olds1 lv == S.index olds2 lv);
mt_olds_inv_equiv #_ #f (lv + 1) (i / 2) olds1 olds2) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.mt_olds_inv_equiv",
"Prims.... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_olds_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
i:nat ->
olds1:hashess #hsz {S.length olds1 = 32} ->
olds2:hashess #hsz {S.length olds2 = 32} ->
Lemma (requires mt_olds_inv #hsz lv i olds1 /\
S.equal (S.slice olds1 lv 32) (S.slice olds2 lv 32))
(ens... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_olds_inv_equiv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv <= 32} ->
i: Prims.nat ->
olds1: MerkleTree.New.High.hashess{FStar.Seq.Base.length olds1 = 32} ->
olds2: MerkleTree.New.High.hashess{FStar.Seq.Base.length olds2 = 32}
-> FStar.Pervasives.Lemma
(requires
MerkleTree.New.High.Correct.Base.mt_olds_inv lv i olds1 /\
... | {
"end_col": 60,
"end_line": 249,
"start_col": 2,
"start_line": 247
} |
Prims.GTot | val mt_rhs_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
smt:MTS.merkle_tree #hsz (log2c j) ->
rhs:hashes #hsz {S.length rhs = log2c j} ->
actd:bool ->
GTot Type0 (decreases j) | [
{
"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":... | false | let rec mt_rhs_inv #_ #f j smt rhs actd =
if j = 0 then true
else begin
(if j % 2 = 1 && actd
then (S.index smt j == MTS.HRaw (S.head rhs))
else true) /\
mt_rhs_inv #_ #f (j / 2) (MTS.mt_next_lv #_ #f #(log2c j) smt) (S.tail rhs)
(actd || (j % 2 = 1))
end | val mt_rhs_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
smt:MTS.merkle_tree #hsz (log2c j) ->
rhs:hashes #hsz {S.length rhs = log2c j} ->
actd:bool ->
GTot Type0 (decreases j)
let rec mt_rhs_inv #_ #f j smt rhs actd = | false | null | false | if j = 0
then true
else
(if j % 2 = 1 && actd then (S.index smt j == MTS.HRaw (S.head rhs)) else true) /\
mt_rhs_inv #_ #f (j / 2) (MTS.mt_next_lv #_ #f #(log2c j) smt) (S.tail rhs) (actd || (j % 2 = 1)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.merkle_tree",
"MerkleTree.New.High.Correct.Base.log2c",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.bool",
"Prims.int",
"Prims.l_and",
"P... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val mt_rhs_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
smt:MTS.merkle_tree #hsz (log2c j) ->
rhs:hashes #hsz {S.length rhs = log2c j} ->
actd:bool ->
GTot Type0 (decreases j) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_rhs_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat ->
smt: MerkleTree.Spec.merkle_tree (MerkleTree.New.High.Correct.Base.log2c j) ->
rhs:
MerkleTree.New.High.hashes
{FStar.Seq.Base.length rhs = MerkleTree.New.High.Correct.Base.log2c j} ->
actd: Prims.bool
-> Prims.GTot Type0 | {
"end_col": 5,
"end_line": 612,
"start_col": 2,
"start_line": 605
} |
FStar.Pervasives.Lemma | val mt_hashes_next_rel_next_even:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 0 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures S.equal (hash_seq_spec #hsz nhs)
(MT... | [
{
"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":... | false | let mt_hashes_next_rel_next_even #hsz #f j hs nhs =
log2c_div j;
mt_hashes_next_rel_lift_even #_ #f j hs nhs;
MTS.mt_next_rel_next_lv #_ #f (log2c j)
(hash_seq_spec #hsz hs) (hash_seq_spec #hsz nhs) | val mt_hashes_next_rel_next_even:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 0 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures S.equal (hash_seq_spec #hsz nhs)
(MT... | false | null | true | log2c_div j;
mt_hashes_next_rel_lift_even #_ #f j hs nhs;
MTS.mt_next_rel_next_lv #_ #f (log2c j) (hash_seq_spec #hsz hs) (hash_seq_spec #hsz nhs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.int",
"Prims.op_Division",
"MerkleTree.Spec.mt_next_rel_next_lv",
"MerkleTree.New.High.C... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val mt_hashes_next_rel_next_even:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 0 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures S.equal (hash_seq_spec #hsz nhs)
(MT... | [] | MerkleTree.New.High.Correct.Base.mt_hashes_next_rel_next_even | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat{j > 1} ->
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs = j} ->
nhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length nhs = j / 2}
-> FStar.Pervasives.Lemma
(requires j % 2 = 0 /\ MerkleTree.New.High.Correct.Base.mt_hashes_next_rel j hs nhs)
(ensures
FStar.Seq.B... | {
"end_col": 52,
"end_line": 487,
"start_col": 2,
"start_line": 484
} |
Prims.GTot | val mt_hashes_lth_inv_log:
#hsz:pos ->
j:nat ->
fhs:hashess #hsz {S.length fhs = log2c j} ->
GTot Type0 (decreases j) | [
{
"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":... | false | let rec mt_hashes_lth_inv_log #hsz j fhs =
if j = 0 then true
else (S.length (S.head fhs) == j /\
mt_hashes_lth_inv_log #hsz (j / 2) (S.tail fhs)) | val mt_hashes_lth_inv_log:
#hsz:pos ->
j:nat ->
fhs:hashess #hsz {S.length fhs = log2c j} ->
GTot Type0 (decreases j)
let rec mt_hashes_lth_inv_log #hsz j fhs = | false | null | false | if j = 0
then true
else (S.length (S.head fhs) == j /\ mt_hashes_lth_inv_log #hsz (j / 2) (S.tail fhs)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"Prims.nat",
"MerkleTree.New.High.hashess",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correct.Base.log2c",
"Prims.int",
"Prims.bool",
"Prims.l_and",
"Prims.eq2",
"MerkleTree.New.High.hash",
"FStar.Seq.Properti... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_hashes_lth_inv_log:
#hsz:pos ->
j:nat ->
fhs:hashess #hsz {S.length fhs = log2c j} ->
GTot Type0 (decreases j) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_log | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat ->
fhs:
MerkleTree.New.High.hashess
{FStar.Seq.Base.length fhs = MerkleTree.New.High.Correct.Base.log2c j}
-> Prims.GTot Type0 | {
"end_col": 55,
"end_line": 326,
"start_col": 2,
"start_line": 324
} |
Prims.GTot | val hash_seq_lift:
#hsz:pos ->
hs:hashes #hsz ->
GTot (shs:MTS.hashes #hsz {S.length shs = S.length hs})
(decreases (S.length hs)) | [
{
"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":... | false | let rec hash_seq_lift #hsz hs =
if S.length hs = 0 then S.empty
else S.cons (MTS.HRaw (S.head hs)) (hash_seq_lift #hsz (S.tail hs)) | val hash_seq_lift:
#hsz:pos ->
hs:hashes #hsz ->
GTot (shs:MTS.hashes #hsz {S.length shs = S.length hs})
(decreases (S.length hs))
let rec hash_seq_lift #hsz hs = | false | null | false | if S.length hs = 0 then S.empty else S.cons (MTS.HRaw (S.head hs)) (hash_seq_lift #hsz (S.tail hs)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"FStar.Seq.Base.empty",
"MerkleTree.Spec.padded_hash",
"Prims.bool",
"FStar.Seq.Properties.cons",
"MerkleTree.Spec.HRaw",
"FStar.Seq.Properties.head",
"MerkleTree... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val hash_seq_lift:
#hsz:pos ->
hs:hashes #hsz ->
GTot (shs:MTS.hashes #hsz {S.length shs = S.length hs})
(decreases (S.length hs)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.hash_seq_lift | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | hs: MerkleTree.New.High.hashes
-> Prims.GTot (shs: MerkleTree.Spec.hashes{FStar.Seq.Base.length shs = FStar.Seq.Base.length hs}) | {
"end_col": 69,
"end_line": 411,
"start_col": 2,
"start_line": 410
} |
Prims.GTot | val merge_hs:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess #hsz ->
hs2:hashess #hsz {S.length hs1 = S.length hs2} ->
GTot (mhs:hashess #hsz {S.length mhs = S.length hs1})
(decreases (S.length hs1)) | [
{
"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":... | false | let rec merge_hs #hsz #f hs1 hs2 =
if S.length hs1 = 0 then S.empty
else (S.cons (S.append (S.head hs1) (S.head hs2))
(merge_hs #_ #f (S.tail hs1) (S.tail hs2))) | val merge_hs:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess #hsz ->
hs2:hashess #hsz {S.length hs1 = S.length hs2} ->
GTot (mhs:hashess #hsz {S.length mhs = S.length hs1})
(decreases (S.length hs1))
let rec merge_hs #hsz #f hs1 hs2 = | false | null | false | if S.length hs1 = 0
then S.empty
else (S.cons (S.append (S.head hs1) (S.head hs2)) (merge_hs #_ #f (S.tail hs1) (S.tail hs2))) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashess",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.int",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Properties.cons",
"FStar.Seq.Base.append",
"MerkleTr... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val merge_hs:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess #hsz ->
hs2:hashess #hsz {S.length hs1 = S.length hs2} ->
GTot (mhs:hashess #hsz {S.length mhs = S.length hs1})
(decreases (S.length hs1)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.merge_hs | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs1: MerkleTree.New.High.hashess ->
hs2: MerkleTree.New.High.hashess{FStar.Seq.Base.length hs1 = FStar.Seq.Base.length hs2}
-> Prims.GTot
(mhs: MerkleTree.New.High.hashess{FStar.Seq.Base.length mhs = FStar.Seq.Base.length hs1}) | {
"end_col": 58,
"end_line": 156,
"start_col": 2,
"start_line": 154
} |
FStar.Pervasives.Lemma | val mt_hashes_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs1:hashess #hsz {S.length fhs1 = 32 /\ mt_hashes_lth_inv lv j fhs1} ->
fhs2:hashess #hsz {S.length fhs2 = 32 /\ mt_hashes_lth_inv lv j fhs2} ->
Lemma (requires mt_hashes_inv #_ #f lv j fhs1 /\
... | [
{
"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":... | false | let rec mt_hashes_inv_equiv #hsz #f lv j fhs1 fhs2 =
if lv = 31 then ()
else (assert (S.index fhs1 lv == S.index fhs2 lv);
assert (S.index fhs1 (lv + 1) == S.index fhs2 (lv + 1));
mt_hashes_inv_equiv #_ #f (lv + 1) (j / 2) fhs1 fhs2) | val mt_hashes_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs1:hashess #hsz {S.length fhs1 = 32 /\ mt_hashes_lth_inv lv j fhs1} ->
fhs2:hashess #hsz {S.length fhs2 = 32 /\ mt_hashes_lth_inv lv j fhs2} ->
Lemma (requires mt_hashes_inv #_ #f lv j fhs1 /\
... | false | null | true | if lv = 31
then ()
else
(assert (S.index fhs1 lv == S.index fhs2 lv);
assert (S.index fhs1 (lv + 1) == S.index fhs2 (lv + 1));
mt_hashes_inv_equiv #_ #f (lv + 1) (j / 2) fhs1 fhs2) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Subtraction",
"MerkleTree.New.High.hashess",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correc... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_hashes_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs1:hashess #hsz {S.length fhs1 = 32 /\ mt_hashes_lth_inv lv j fhs1} ->
fhs2:hashess #hsz {S.length fhs2 = 32 /\ mt_hashes_lth_inv lv j fhs2} ->
Lemma (requires mt_hashes_inv #_ #f lv j fhs1 /\
... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_inv_equiv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv < 32} ->
j: Prims.nat{j < Prims.pow2 (32 - lv)} ->
fhs1:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length fhs1 = 32 /\
MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv lv j fhs1 } ->
fhs2:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length fh... | {
"end_col": 60,
"end_line": 145,
"start_col": 2,
"start_line": 142
} |
Prims.GTot | val mt_base:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot (bhs:hashes #hsz {S.length bhs = MT?.j mt}) | [
{
"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":... | false | let mt_base #hsz mt olds =
S.head (merge_hs #hsz #(MT?.hash_fun mt) olds (MT?.hs mt)) | val mt_base:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot (bhs:hashes #hsz {S.length bhs = MT?.j mt})
let mt_base #hsz mt olds = | false | null | false | S.head (merge_hs #hsz #(MT?.hash_fun mt) olds (MT?.hs mt)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.New.High.merkle_tree",
"MerkleTree.New.High.mt_wf_elts",
"MerkleTree.New.High.hashess",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correct.Base.mt_olds_inv",
"MerkleTree.New.... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val mt_base:
#hsz:pos ->
mt:merkle_tree #hsz {mt_wf_elts mt} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz 0 (MT?.i mt) olds} ->
GTot (bhs:hashes #hsz {S.length bhs = MT?.j mt}) | [] | MerkleTree.New.High.Correct.Base.mt_base | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
mt: MerkleTree.New.High.merkle_tree{MerkleTree.New.High.mt_wf_elts mt} ->
olds:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length olds = 32 /\
MerkleTree.New.High.Correct.Base.mt_olds_inv 0 (MT?.i mt) olds }
-> Prims.GTot (bhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length bhs = ... | {
"end_col": 60,
"end_line": 630,
"start_col": 2,
"start_line": 630
} |
Prims.GTot | val mt_hashes_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32 /\ mt_hashes_lth_inv lv j fhs} ->
GTot Type0 (decreases (32 - lv)) | [
{
"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":... | false | let rec mt_hashes_inv #hsz #f lv j fhs =
if lv = 31 then true
else (mt_hashes_next_rel #_ #f j (S.index fhs lv) (S.index fhs (lv + 1)) /\
mt_hashes_inv #_ #f (lv + 1) (j / 2) fhs) | val mt_hashes_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32 /\ mt_hashes_lth_inv lv j fhs} ->
GTot Type0 (decreases (32 - lv))
let rec mt_hashes_inv #hsz #f lv j fhs = | false | null | false | if lv = 31
then true
else
(mt_hashes_next_rel #_ #f j (S.index fhs lv) (S.index fhs (lv + 1)) /\
mt_hashes_inv #_ #f (lv + 1) (j / 2) fhs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Subtraction",
"MerkleTree.New.High.hashess",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correc... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mt_hashes_inv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32 /\ mt_hashes_lth_inv lv j fhs} ->
GTot Type0 (decreases (32 - lv)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv < 32} ->
j: Prims.nat{j < Prims.pow2 (32 - lv)} ->
fhs:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length fhs = 32 /\
MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv lv j fhs }
-> Prims.GTot Type0 | {
"end_col": 48,
"end_line": 100,
"start_col": 2,
"start_line": 98
} |
FStar.Pervasives.Lemma | val merge_hs_index:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess ->
hs2:hashess{S.length hs1 = S.length hs2} ->
i:nat{i < S.length hs1} ->
Lemma (requires True)
(ensures S.equal (S.index (merge_hs #_ #f hs1 hs2) i)
(S.append (S.index hs1 i) (S.index hs2 i)))
(decr... | [
{
"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":... | false | let rec merge_hs_index #hsz #f hs1 hs2 i =
if S.length hs1 = 0 then ()
else if i = 0 then ()
else merge_hs_index #_ #f (S.tail hs1) (S.tail hs2) (i - 1) | val merge_hs_index:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess ->
hs2:hashess{S.length hs1 = S.length hs2} ->
i:nat{i < S.length hs1} ->
Lemma (requires True)
(ensures S.equal (S.index (merge_hs #_ #f hs1 hs2) i)
(S.append (S.index hs1 i) (S.index hs2 i)))
(decr... | false | null | true | if S.length hs1 = 0
then ()
else if i = 0 then () else merge_hs_index #_ #f (S.tail hs1) (S.tail hs2) (i - 1) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashess",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.op_LessThan",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.merge_hs_index",
"FStar.Seq.Proper... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val merge_hs_index:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess ->
hs2:hashess{S.length hs1 = S.length hs2} ->
i:nat{i < S.length hs1} ->
Lemma (requires True)
(ensures S.equal (S.index (merge_hs #_ #f hs1 hs2) i)
(S.append (S.index hs1 i) (S.index hs2 i)))
(decr... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.merge_hs_index | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs1: MerkleTree.New.High.hashess ->
hs2: MerkleTree.New.High.hashess{FStar.Seq.Base.length hs1 = FStar.Seq.Base.length hs2} ->
i: Prims.nat{i < FStar.Seq.Base.length hs1}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (FStar.Seq.Base.index (MerkleTree.New.High.Correct.Base.merge_hs... | {
"end_col": 61,
"end_line": 188,
"start_col": 2,
"start_line": 186
} |
Prims.GTot | val mt_hashes_inv_log:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
fhs:hashess #hsz {S.length fhs = log2c j /\ mt_hashes_lth_inv_log #hsz j fhs} ->
GTot Type0 (decreases j) | [
{
"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":... | false | let rec mt_hashes_inv_log #hsz #f j fhs =
if j <= 1 then true
else (mt_hashes_next_rel #_ #f j (S.index fhs 0) (S.index fhs 1) /\
mt_hashes_inv_log #_ #f (j / 2) (S.tail fhs)) | val mt_hashes_inv_log:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
fhs:hashess #hsz {S.length fhs = log2c j /\ mt_hashes_lth_inv_log #hsz j fhs} ->
GTot Type0 (decreases j)
let rec mt_hashes_inv_log #hsz #f j fhs = | false | null | false | if j <= 1
then true
else
(mt_hashes_next_rel #_ #f j (S.index fhs 0) (S.index fhs 1) /\
mt_hashes_inv_log #_ #f (j / 2) (S.tail fhs)) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.New.High.hashess",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correct.Base.log2c",
"MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_log",
"Pr... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mt_hashes_inv_log:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat ->
fhs:hashess #hsz {S.length fhs = log2c j /\ mt_hashes_lth_inv_log #hsz j fhs} ->
GTot Type0 (decreases j) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_inv_log | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat ->
fhs:
MerkleTree.New.High.hashess
{ FStar.Seq.Base.length fhs = MerkleTree.New.High.Correct.Base.log2c j /\
MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_log j fhs }
-> Prims.GTot Type0 | {
"end_col": 52,
"end_line": 347,
"start_col": 2,
"start_line": 345
} |
FStar.Pervasives.Lemma | val mt_hashes_lth_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs1:hashess{S.length fhs1 = 32} ->
fhs2:hashess{S.length fhs2 = 32} ->
Lemma (requires mt_hashes_lth_inv lv j fhs1 /\
S.equal (S.slice fhs1 lv 32) (S.slice fhs2 lv 32))
... | [
{
"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":... | false | let rec mt_hashes_lth_inv_equiv #hsz #f lv j fhs1 fhs2 =
if lv = 31 then ()
else (assert (S.index fhs1 lv == S.index fhs2 lv);
mt_hashes_lth_inv_equiv #_ #f (lv + 1) (j / 2) fhs1 fhs2) | val mt_hashes_lth_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs1:hashess{S.length fhs1 = 32} ->
fhs2:hashess{S.length fhs2 = 32} ->
Lemma (requires mt_hashes_lth_inv lv j fhs1 /\
S.equal (S.slice fhs1 lv 32) (S.slice fhs2 lv 32))
... | false | null | true | if lv = 31
then ()
else
(assert (S.index fhs1 lv == S.index fhs2 lv);
mt_hashes_lth_inv_equiv #_ #f (lv + 1) (j / 2) fhs1 fhs2) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"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",
"MerkleTree.New.High.Correct... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mt_hashes_lth_inv_equiv:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv < 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs1:hashess{S.length fhs1 = 32} ->
fhs2:hashess{S.length fhs2 = 32} ->
Lemma (requires mt_hashes_lth_inv lv j fhs1 /\
S.equal (S.slice fhs1 lv 32) (S.slice fhs2 lv 32))
... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_equiv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv < 32} ->
j: Prims.nat{j < Prims.pow2 (32 - lv)} ->
fhs1: MerkleTree.New.High.hashess{FStar.Seq.Base.length fhs1 = 32} ->
fhs2: MerkleTree.New.High.hashess{FStar.Seq.Base.length fhs2 = 32}
-> FStar.Pervasives.Lemma
(requires
MerkleTree.New.High.Correct.Base.mt_hashes_lth... | {
"end_col": 64,
"end_line": 127,
"start_col": 2,
"start_line": 125
} |
FStar.Pervasives.Lemma | val mt_olds_hs_lth_inv_ok:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
i:nat ->
j:nat{i <= j /\ j < pow2 (32 - lv)} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz lv i olds} ->
hs:hashess #hsz {S.length hs = 32 /\ hs_wf_elts #hsz lv hs i j} ->
Lemma (requires True)
(ens... | [
{
"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":... | false | let rec mt_olds_hs_lth_inv_ok #hsz #f lv i j olds hs =
if lv = 32 then ()
else (mt_olds_hs_lth_inv_ok #_ #f (lv + 1) (i / 2) (j / 2) olds hs) | val mt_olds_hs_lth_inv_ok:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
i:nat ->
j:nat{i <= j /\ j < pow2 (32 - lv)} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz lv i olds} ->
hs:hashess #hsz {S.length hs = 32 /\ hs_wf_elts #hsz lv hs i j} ->
Lemma (requires True)
(ens... | false | null | true | if lv = 32 then () else (mt_olds_hs_lth_inv_ok #_ #f (lv + 1) (i / 2) (j / 2) olds hs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"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",... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val mt_olds_hs_lth_inv_ok:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
i:nat ->
j:nat{i <= j /\ j < pow2 (32 - lv)} ->
olds:hashess #hsz {S.length olds = 32 /\ mt_olds_inv #hsz lv i olds} ->
hs:hashess #hsz {S.length hs = 32 /\ hs_wf_elts #hsz lv hs i j} ->
Lemma (requires True)
(ens... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_olds_hs_lth_inv_ok | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv <= 32} ->
i: Prims.nat ->
j: Prims.nat{i <= j /\ j < Prims.pow2 (32 - lv)} ->
olds:
MerkleTree.New.High.hashess
{FStar.Seq.Base.length olds = 32 /\ MerkleTree.New.High.Correct.Base.mt_olds_inv lv i olds} ->
hs:
MerkleTree.New.High.hashess
{FStar.Seq.Base... | {
"end_col": 69,
"end_line": 263,
"start_col": 2,
"start_line": 262
} |
FStar.Pervasives.Lemma | val hash_seq_spec_full_next:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
acc:hash #hsz -> actd:bool -> nacc:hash #hsz -> nactd:bool ->
Lemma
(requires mt_hashes_next_rel #_ #f j hs nhs /\
nacc == (if j ... | [
{
"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":... | false | let hash_seq_spec_full_next #_ #f j hs nhs acc actd nacc nactd =
if j % 2 = 0
then hash_seq_spec_full_even_next #_ #f j hs nhs acc actd
else hash_seq_spec_full_odd_next #_ #f j hs nhs acc actd nacc | val hash_seq_spec_full_next:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
acc:hash #hsz -> actd:bool -> nacc:hash #hsz -> nactd:bool ->
Lemma
(requires mt_hashes_next_rel #_ #f j hs nhs /\
nacc == (if j ... | false | null | true | if j % 2 = 0
then hash_seq_spec_full_even_next #_ #f j hs nhs acc actd
else hash_seq_spec_full_odd_next #_ #f j hs nhs acc actd nacc | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.int",
"Prims.op_Division",
"Prims.bool",
"Prims.op_Modulus",
"MerkleTree.New.High.Corr... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val hash_seq_spec_full_next:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
acc:hash #hsz -> actd:bool -> nacc:hash #hsz -> nactd:bool ->
Lemma
(requires mt_hashes_next_rel #_ #f j hs nhs /\
nacc == (if j ... | [] | MerkleTree.New.High.Correct.Base.hash_seq_spec_full_next | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat{j > 1} ->
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs = j} ->
nhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length nhs = j / 2} ->
acc: MerkleTree.New.High.hash ->
actd: Prims.bool ->
nacc: MerkleTree.New.High.hash ->
nactd: Prims.bool
-> FStar.Pervasives.Lemma
... | {
"end_col": 63,
"end_line": 595,
"start_col": 2,
"start_line": 593
} |
FStar.Pervasives.Lemma | val hash_seq_lift_index:
#hsz:pos ->
hs:hashes #hsz ->
Lemma (requires True)
(ensures forall (i:nat{i < S.length hs}).
S.index (hash_seq_lift #hsz hs) i == MTS.HRaw (S.index hs i))
(decreases (S.length hs)) | [
{
"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":... | false | let rec hash_seq_lift_index #hsz hs =
if S.length hs = 0 then ()
else hash_seq_lift_index #hsz (S.tail hs) | val hash_seq_lift_index:
#hsz:pos ->
hs:hashes #hsz ->
Lemma (requires True)
(ensures forall (i:nat{i < S.length hs}).
S.index (hash_seq_lift #hsz hs) i == MTS.HRaw (S.index hs i))
(decreases (S.length hs))
let rec hash_seq_lift_index #hsz hs = | false | null | true | if S.length hs = 0 then () else hash_seq_lift_index #hsz (S.tail hs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.hash_seq_lift_index",
"FStar.Seq.Properties.tail",
"Prims.unit"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val hash_seq_lift_index:
#hsz:pos ->
hs:hashes #hsz ->
Lemma (requires True)
(ensures forall (i:nat{i < S.length hs}).
S.index (hash_seq_lift #hsz hs) i == MTS.HRaw (S.index hs i))
(decreases (S.length hs)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.hash_seq_lift_index | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | hs: MerkleTree.New.High.hashes
-> FStar.Pervasives.Lemma
(ensures
forall (i: Prims.nat{i < FStar.Seq.Base.length hs}).
FStar.Seq.Base.index (MerkleTree.New.High.Correct.Base.hash_seq_lift hs) i ==
MerkleTree.Spec.HRaw (FStar.Seq.Base.index hs i)) (decreases FStar.Seq.Base.length hs) | {
"end_col": 43,
"end_line": 423,
"start_col": 2,
"start_line": 422
} |
FStar.Pervasives.Lemma | val merge_hs_slice_equal:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
ahs1:hashess #hsz ->
ahs2:hashess #hsz {S.length ahs1 = S.length ahs2} ->
bhs1:hashess #hsz ->
bhs2:hashess #hsz {S.length bhs1 = S.length bhs2} ->
i:nat -> j:nat{i <= j && j <= S.length ahs1 && j <= S.length bhs1} ->
Lemma (requires S.equal ... | [
{
"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":... | false | let rec merge_hs_slice_equal #_ #f ahs1 ahs2 bhs1 bhs2 i j =
if i = j then ()
else (assert (S.index ahs1 i == S.index bhs1 i);
assert (S.index ahs2 i == S.index bhs2 i);
merge_hs_slice_equal #_ #f ahs1 ahs2 bhs1 bhs2 (i + 1) j) | val merge_hs_slice_equal:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
ahs1:hashess #hsz ->
ahs2:hashess #hsz {S.length ahs1 = S.length ahs2} ->
bhs1:hashess #hsz ->
bhs2:hashess #hsz {S.length bhs1 = S.length bhs2} ->
i:nat -> j:nat{i <= j && j <= S.length ahs1 && j <= S.length bhs1} ->
Lemma (requires S.equal ... | false | null | true | if i = j
then ()
else
(assert (S.index ahs1 i == S.index bhs1 i);
assert (S.index ahs2 i == S.index bhs2 i);
merge_hs_slice_equal #_ #f ahs1 ahs2 bhs1 bhs2 (i + 1) j) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashess",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.merge_hs_slice_equal",
... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val merge_hs_slice_equal:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
ahs1:hashess #hsz ->
ahs2:hashess #hsz {S.length ahs1 = S.length ahs2} ->
bhs1:hashess #hsz ->
bhs2:hashess #hsz {S.length bhs1 = S.length bhs2} ->
i:nat -> j:nat{i <= j && j <= S.length ahs1 && j <= S.length bhs1} ->
Lemma (requires S.equal ... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.merge_hs_slice_equal | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
ahs1: MerkleTree.New.High.hashess ->
ahs2: MerkleTree.New.High.hashess{FStar.Seq.Base.length ahs1 = FStar.Seq.Base.length ahs2} ->
bhs1: MerkleTree.New.High.hashess ->
bhs2: MerkleTree.New.High.hashess{FStar.Seq.Base.length bhs1 = FStar.Seq.Base.length bhs2} ->
i: Prims.nat ->
j: Prims.nat{i <=... | {
"end_col": 64,
"end_line": 206,
"start_col": 2,
"start_line": 203
} |
FStar.Pervasives.Lemma | val merge_hs_upd:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess #hsz ->
hs2:hashess #hsz {S.length hs1 = S.length hs2} ->
i:nat{i < S.length hs1} ->
v1:hashes #hsz -> v2:hashes #hsz ->
Lemma (requires S.equal (S.append (S.index hs1 i) (S.index hs2 i))
(S.append v1 v2))
... | [
{
"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":... | false | let rec merge_hs_upd #_ #f hs1 hs2 i v1 v2 =
if S.length hs1 = 0 then ()
else if i = 0 then ()
else merge_hs_upd #_ #f (S.tail hs1) (S.tail hs2) (i - 1) v1 v2 | val merge_hs_upd:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess #hsz ->
hs2:hashess #hsz {S.length hs1 = S.length hs2} ->
i:nat{i < S.length hs1} ->
v1:hashes #hsz -> v2:hashes #hsz ->
Lemma (requires S.equal (S.append (S.index hs1 i) (S.index hs2 i))
(S.append v1 v2))
... | false | null | true | if S.length hs1 = 0
then ()
else if i = 0 then () else merge_hs_upd #_ #f (S.tail hs1) (S.tail hs2) (i - 1) v1 v2 | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashess",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"Prims.op_LessThan",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.merge_hs_upd",
"FStar.Seq.Properti... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val merge_hs_upd:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs1:hashess #hsz ->
hs2:hashess #hsz {S.length hs1 = S.length hs2} ->
i:nat{i < S.length hs1} ->
v1:hashes #hsz -> v2:hashes #hsz ->
Lemma (requires S.equal (S.append (S.index hs1 i) (S.index hs2 i))
(S.append v1 v2))
... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.merge_hs_upd | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs1: MerkleTree.New.High.hashess ->
hs2: MerkleTree.New.High.hashess{FStar.Seq.Base.length hs1 = FStar.Seq.Base.length hs2} ->
i: Prims.nat{i < FStar.Seq.Base.length hs1} ->
v1: MerkleTree.New.High.hashes ->
v2: MerkleTree.New.High.hashes
-> FStar.Pervasives.Lemma
(requires
FStar.Se... | {
"end_col": 65,
"end_line": 222,
"start_col": 2,
"start_line": 220
} |
Prims.GTot | 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)) | [
{
"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":... | false | 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) | 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 = | false | null | false | if lv = 32 then true else (S.length (S.index fhs lv) == j /\ mt_hashes_lth_inv (lv + 1) (j / 2) fhs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"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",
... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | 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)) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
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 | {
"end_col": 46,
"end_line": 65,
"start_col": 2,
"start_line": 63
} |
FStar.Pervasives.Lemma | val mt_hashes_lth_inv_log_converted_:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32} ->
Lemma (requires mt_hashes_lth_inv #hsz lv j fhs)
(ensures (log2c_bound j (32 - lv);
mt_hashes_lth_inv_log #hsz j (S.sli... | [
{
"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":... | false | let rec mt_hashes_lth_inv_log_converted_ #_ #f lv j fhs =
if j = 0 then ()
else (log2c_bound (j / 2) (32 - (lv + 1));
mt_hashes_lth_inv_log_converted_ #_ #f (lv + 1) (j / 2) fhs) | val mt_hashes_lth_inv_log_converted_:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32} ->
Lemma (requires mt_hashes_lth_inv #hsz lv j fhs)
(ensures (log2c_bound j (32 - lv);
mt_hashes_lth_inv_log #hsz j (S.sli... | false | null | true | if j = 0
then ()
else
(log2c_bound (j / 2) (32 - (lv + 1));
mt_hashes_lth_inv_log_converted_ #_ #f (lv + 1) (j / 2) fhs) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma",
""
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"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",
... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mt_hashes_lth_inv_log_converted_:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
lv:nat{lv <= 32} ->
j:nat{j < pow2 (32 - lv)} ->
fhs:hashess #hsz {S.length fhs = 32} ->
Lemma (requires mt_hashes_lth_inv #hsz lv j fhs)
(ensures (log2c_bound j (32 - lv);
mt_hashes_lth_inv_log #hsz j (S.sli... | [
"recursion"
] | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_log_converted_ | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
lv: Prims.nat{lv <= 32} ->
j: Prims.nat{j < Prims.pow2 (32 - lv)} ->
fhs: MerkleTree.New.High.hashess{FStar.Seq.Base.length fhs = 32}
-> FStar.Pervasives.Lemma (requires MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv lv j fhs)
(ensures
([@@ FStar.Pervasives.inline_let ]let _ =
... | {
"end_col": 67,
"end_line": 361,
"start_col": 2,
"start_line": 359
} |
FStar.Pervasives.Lemma | val hash_seq_spec_full_odd_next:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
acc:hash #hsz -> actd:bool -> nacc:hash #hsz ->
Lemma
(requires j % 2 = 1 /\
mt_hashes_next_rel #_ #f j hs nhs /\
... | [
{
"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":... | false | let hash_seq_spec_full_odd_next #hsz #f j hs nhs acc actd nacc =
log2c_div j;
mt_hashes_next_rel_lift_odd #_ #f j hs nhs;
if actd
then begin
MTS.mt_next_rel_upd_odd #_ #f (log2c j)
(hash_seq_spec #hsz hs)
(S.upd (hash_seq_spec #hsz nhs) (S.length nhs) (MTS.HRaw (S.last hs)))
(S.length nhs)... | val hash_seq_spec_full_odd_next:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
acc:hash #hsz -> actd:bool -> nacc:hash #hsz ->
Lemma
(requires j % 2 = 1 /\
mt_hashes_next_rel #_ #f j hs nhs /\
... | false | null | true | log2c_div j;
mt_hashes_next_rel_lift_odd #_ #f j hs nhs;
if actd
then
(MTS.mt_next_rel_upd_odd #_
#f
(log2c j)
(hash_seq_spec #hsz hs)
(S.upd (hash_seq_spec #hsz nhs) (S.length nhs) (MTS.HRaw (S.last hs)))
(S.length nhs)
(MTS.HRaw acc);
MTS.mt_next_rel_next_lv #_
#f
... | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.int",
"Prims.op_Division",
"Prims.bool",
"MerkleTree.Spec.mt_next_rel_next_lv",
"Merkl... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val hash_seq_spec_full_odd_next:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
acc:hash #hsz -> actd:bool -> nacc:hash #hsz ->
Lemma
(requires j % 2 = 1 /\
mt_hashes_next_rel #_ #f j hs nhs /\
... | [] | MerkleTree.New.High.Correct.Base.hash_seq_spec_full_odd_next | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat{j > 1} ->
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs = j} ->
nhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length nhs = j / 2} ->
acc: MerkleTree.New.High.hash ->
actd: Prims.bool ->
nacc: MerkleTree.New.High.hash
-> FStar.Pervasives.Lemma
(requires
j ... | {
"end_col": 49,
"end_line": 573,
"start_col": 2,
"start_line": 559
} |
FStar.Pervasives.Lemma | val mt_hashes_next_rel_lift_even:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 0 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures MTS.mt_next_rel #_ #f (log2c j)
(hash_seq_sp... | [
{
"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":... | false | let mt_hashes_next_rel_lift_even #hsz #_ j hs nhs =
hash_seq_lift_index #hsz hs;
hash_seq_lift_index #hsz nhs | val mt_hashes_next_rel_lift_even:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 0 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures MTS.mt_next_rel #_ #f (log2c j)
(hash_seq_sp... | false | null | true | hash_seq_lift_index #hsz hs;
hash_seq_lift_index #hsz nhs | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.int",
"Prims.op_Division",
"MerkleTree.New.High.Correct.Base.hash_seq_lift_index",
"Prim... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val mt_hashes_next_rel_lift_even:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 0 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures MTS.mt_next_rel #_ #f (log2c j)
(hash_seq_sp... | [] | MerkleTree.New.High.Correct.Base.mt_hashes_next_rel_lift_even | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat{j > 1} ->
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs = j} ->
nhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length nhs = j / 2}
-> FStar.Pervasives.Lemma
(requires j % 2 = 0 /\ MerkleTree.New.High.Correct.Base.mt_hashes_next_rel j hs nhs)
(ensures
MerkleTree.... | {
"end_col": 30,
"end_line": 458,
"start_col": 2,
"start_line": 457
} |
FStar.Pervasives.Lemma | val mt_hashes_next_rel_lift_odd:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 1 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures MTS.mt_next_rel #_ #f (log2c j)
(hash_seq_sp... | [
{
"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":... | false | let mt_hashes_next_rel_lift_odd #hsz #_ j hs nhs =
log2c_div j;
hash_seq_lift_index #hsz hs;
hash_seq_lift_index #hsz nhs | val mt_hashes_next_rel_lift_odd:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 1 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures MTS.mt_next_rel #_ #f (log2c j)
(hash_seq_sp... | false | null | true | log2c_div j;
hash_seq_lift_index #hsz hs;
hash_seq_lift_index #hsz nhs | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"MerkleTree.New.High.hashes",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.int",
"Prims.op_Division",
"MerkleTree.New.High.Correct.Base.hash_seq_lift_index",
"Prim... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val mt_hashes_next_rel_lift_odd:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j > 1} ->
hs:hashes #hsz {S.length hs = j} ->
nhs:hashes #hsz {S.length nhs = j / 2} ->
Lemma (requires j % 2 = 1 /\ mt_hashes_next_rel #_ #f j hs nhs)
(ensures MTS.mt_next_rel #_ #f (log2c j)
(hash_seq_sp... | [] | MerkleTree.New.High.Correct.Base.mt_hashes_next_rel_lift_odd | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
j: Prims.nat{j > 1} ->
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs = j} ->
nhs: MerkleTree.New.High.hashes{FStar.Seq.Base.length nhs = j / 2}
-> FStar.Pervasives.Lemma
(requires j % 2 = 1 /\ MerkleTree.New.High.Correct.Base.mt_hashes_next_rel j hs nhs)
(ensures
MerkleTree.... | {
"end_col": 30,
"end_line": 473,
"start_col": 2,
"start_line": 471
} |
FStar.Pervasives.Lemma | val log2c_bound:
n:nat -> c:nat{n < pow2 c} ->
Lemma (log2c n <= c) | [
{
"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":... | false | let rec log2c_bound n c =
if n = 0 then ()
else log2c_bound (n / 2) (c - 1) | val log2c_bound:
n:nat -> c:nat{n < pow2 c} ->
Lemma (log2c n <= c)
let rec log2c_bound n c = | false | null | true | if n = 0 then () else log2c_bound (n / 2) (c - 1) | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.New.High.Correct.Base.log2c_bound",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"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... | null | val log2c_bound:
n:nat -> c:nat{n < pow2 c} ->
Lemma (log2c n <= c) | [
"recursion"
] | MerkleTree.New.High.Correct.Base.log2c_bound | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | n: Prims.nat -> c: Prims.nat{n < Prims.pow2 c}
-> FStar.Pervasives.Lemma (ensures MerkleTree.New.High.Correct.Base.log2c n <= c) | {
"end_col": 34,
"end_line": 316,
"start_col": 2,
"start_line": 315
} |
Prims.GTot | val hash_seq_spec_full:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs:hashes #hsz {S.length hs > 0} ->
acc:hash #hsz -> actd:bool ->
GTot (MTS.merkle_tree #hsz (log2c (S.length hs))) | [
{
"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":... | false | let hash_seq_spec_full #hsz #f hs acc actd =
if actd
then (S.upd (hash_seq_spec #hsz hs) (S.length hs) (MTS.HRaw acc))
else hash_seq_spec #hsz hs | val hash_seq_spec_full:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs:hashes #hsz {S.length hs > 0} ->
acc:hash #hsz -> actd:bool ->
GTot (MTS.merkle_tree #hsz (log2c (S.length hs)))
let hash_seq_spec_full #hsz #f hs acc actd = | false | null | false | if actd then (S.upd (hash_seq_spec #hsz hs) (S.length hs) (MTS.HRaw acc)) else hash_seq_spec #hsz hs | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"sometrivial"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.New.High.hashes",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hash",
"Prims.bool",
"FStar.Seq.Base.upd",
"MerkleTree.Spec.padded_hash",
"MerkleTree.New.High.Correct.Base.hash_seq_spec",
"MerkleTree.Sp... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"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... | null | val hash_seq_spec_full:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
hs:hashes #hsz {S.length hs > 0} ->
acc:hash #hsz -> actd:bool ->
GTot (MTS.merkle_tree #hsz (log2c (S.length hs))) | [] | MerkleTree.New.High.Correct.Base.hash_seq_spec_full | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} |
hs: MerkleTree.New.High.hashes{FStar.Seq.Base.length hs > 0} ->
acc: MerkleTree.New.High.hash ->
actd: Prims.bool
-> Prims.GTot
(MerkleTree.Spec.merkle_tree (MerkleTree.New.High.Correct.Base.log2c (FStar.Seq.Base.length hs))
) | {
"end_col": 28,
"end_line": 497,
"start_col": 2,
"start_line": 495
} |
FStar.Pervasives.Lemma | val mt_hashes_lth_inv_log_converted:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j < pow2 32} ->
fhs:hashess #hsz {S.length fhs = 32} ->
Lemma (requires mt_hashes_lth_inv #hsz 0 j fhs)
(ensures (log2c_bound j 32;
mt_hashes_lth_inv_log #hsz j (S.slice fhs 0 (log2c j)))) | [
{
"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":... | false | let mt_hashes_lth_inv_log_converted #_ #f j fhs =
mt_hashes_lth_inv_log_converted_ #_ #f 0 j fhs | val mt_hashes_lth_inv_log_converted:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j < pow2 32} ->
fhs:hashess #hsz {S.length fhs = 32} ->
Lemma (requires mt_hashes_lth_inv #hsz 0 j fhs)
(ensures (log2c_bound j 32;
mt_hashes_lth_inv_log #hsz j (S.slice fhs 0 (log2c j))))
let mt_hashes_lt... | false | null | true | mt_hashes_lth_inv_log_converted_ #_ #f 0 j fhs | {
"checked_file": "MerkleTree.New.High.Correct.Base.fst.checked",
"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"
... | [
"lemma"
] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"MerkleTree.New.High.hashess",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.New.High.hashes",
"MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_log_converted_",
... | [] | 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 ... | false | false | MerkleTree.New.High.Correct.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mt_hashes_lth_inv_log_converted:
#hsz:pos -> #f:MTS.hash_fun_t #hsz ->
j:nat{j < pow2 32} ->
fhs:hashess #hsz {S.length fhs = 32} ->
Lemma (requires mt_hashes_lth_inv #hsz 0 j fhs)
(ensures (log2c_bound j 32;
mt_hashes_lth_inv_log #hsz j (S.slice fhs 0 (log2c j)))) | [] | MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv_log_converted | {
"file_name": "src/MerkleTree.New.High.Correct.Base.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | j: Prims.nat{j < Prims.pow2 32} -> fhs: MerkleTree.New.High.hashess{FStar.Seq.Base.length fhs = 32}
-> FStar.Pervasives.Lemma (requires MerkleTree.New.High.Correct.Base.mt_hashes_lth_inv 0 j fhs)
(ensures
([@@ FStar.Pervasives.inline_let ]let _ =
MerkleTree.New.High.Correct.Base.log2c_bound ... | {
"end_col": 48,
"end_line": 371,
"start_col": 2,
"start_line": 371
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.