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
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 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
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val sha3_224:impl | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sha3_224: impl = (| SHA3_224, () |) | val sha3_224:impl
let sha3_224:impl = | false | null | false | (| SHA3_224, () |) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.SHA3_224"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |) | false | true | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_224:impl | [] | EverCrypt.Hash.sha3_224 | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | EverCrypt.Hash.impl | {
"end_col": 39,
"end_line": 79,
"start_col": 21,
"start_line": 79
} |
Prims.Tot | val blake2b_256:impl | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |) | val blake2b_256:impl
let blake2b_256:impl = | false | null | false | (| Blake2B, Hacl.Impl.Blake2.Core.M256 |) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Impl.Blake2.Core.M256"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |) | false | true | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blake2b_256:impl | [] | EverCrypt.Hash.blake2b_256 | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | EverCrypt.Hash.impl | {
"end_col": 65,
"end_line": 93,
"start_col": 24,
"start_line": 93
} |
Prims.Tot | val sha3_512:impl | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sha3_512: impl = (| SHA3_512, () |) | val sha3_512:impl
let sha3_512:impl = | false | null | false | (| SHA3_512, () |) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.SHA3_512"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |) | false | true | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_512:impl | [] | EverCrypt.Hash.sha3_512 | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | EverCrypt.Hash.impl | {
"end_col": 39,
"end_line": 85,
"start_col": 21,
"start_line": 85
} |
Prims.Tot | val alg_of_impl (i: impl{is_valid_impl i}) : alg | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i | val alg_of_impl (i: impl{is_valid_impl i}) : alg
let alg_of_impl (i: impl{is_valid_impl i}) : alg = | false | null | false | dfst i | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.impl",
"Prims.b2t",
"EverCrypt.Hash.is_valid_impl",
"FStar.Pervasives.dfst",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"EverCrypt.Hash.alg"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |) | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alg_of_impl (i: impl{is_valid_impl i}) : alg | [] | EverCrypt.Hash.alg_of_impl | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: EverCrypt.Hash.impl{EverCrypt.Hash.is_valid_impl i} -> EverCrypt.Hash.alg | {
"end_col": 59,
"end_line": 96,
"start_col": 53,
"start_line": 96
} |
Prims.Tot | val blake2s_32:impl | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |) | val blake2s_32:impl
let blake2s_32:impl = | false | null | false | (| Blake2S, Hacl.Impl.Blake2.Core.M32 |) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |) | false | true | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blake2s_32:impl | [] | EverCrypt.Hash.blake2s_32 | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | EverCrypt.Hash.impl | {
"end_col": 63,
"end_line": 87,
"start_col": 23,
"start_line": 87
} |
FStar.HyperStack.ST.ST | val create: a:alg -> ST (state a)
(requires fun h0 -> True)
(ensures fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
freeable h1 s) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let create a =
create_in a HS.root | val create: a:alg -> ST (state a)
(requires fun h0 -> True)
(ensures fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
freeable h1 s)
let create a = | true | null | false | create_in a HS.root | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [] | [
"EverCrypt.Hash.alg",
"EverCrypt.Hash.create_in",
"FStar.Monotonic.HyperHeap.root",
"EverCrypt.Hash.state"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val create: a:alg -> ST (state a)
(requires fun h0 -> True)
(ensures fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
freeable h1 s) | [] | EverCrypt.Hash.create | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: EverCrypt.Hash.alg -> FStar.HyperStack.ST.ST (EverCrypt.Hash.state a) | {
"end_col": 21,
"end_line": 298,
"start_col": 2,
"start_line": 298
} |
Prims.Tot | val impl_of_state (#a: _) (s: state_s a) : i: impl{alg_of_impl i == a} | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256 | val impl_of_state (#a: _) (s: state_s a) : i: impl{alg_of_impl i == a}
let impl_of_state #a (s: state_s a) : i: impl{alg_of_impl i == a} = | false | null | false | match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256 | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.fixed_len_alg",
"EverCrypt.Hash.state_s",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"EverCrypt.Hash.md5",
"Spec.Hash.Definitions.SHA1",
"EverCrypt.Hash.sha1",
"Spec.Hash.Definitions.SHA2_224",
"EverCrypt.Hash.sha2_224",
"Spec.Hash.Definitions.SHA2_256",
"EverCrypt.Hash.sha2_256",
"Spec.Hash.Definitions.SHA2_384",
"EverCrypt.Hash.sha2_384",
"Spec.Hash.Definitions.SHA2_512",
"EverCrypt.Hash.sha2_512",
"Spec.Hash.Definitions.SHA3_224",
"EverCrypt.Hash.sha3_224",
"Spec.Hash.Definitions.SHA3_256",
"EverCrypt.Hash.sha3_256",
"Spec.Hash.Definitions.SHA3_384",
"EverCrypt.Hash.sha3_384",
"Spec.Hash.Definitions.SHA3_512",
"EverCrypt.Hash.sha3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"EverCrypt.Hash.blake2s_32",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"EverCrypt.Hash.blake2s_128",
"Spec.Hash.Definitions.Blake2B",
"EverCrypt.Hash.blake2b_32",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"EverCrypt.Hash.blake2b_256",
"EverCrypt.Hash.impl",
"Prims.eq2",
"EverCrypt.Hash.alg_of_impl"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val impl_of_state (#a: _) (s: state_s a) : i: impl{alg_of_impl i == a} | [] | EverCrypt.Hash.impl_of_state | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: EverCrypt.Hash.state_s a -> i: EverCrypt.Hash.impl{EverCrypt.Hash.alg_of_impl i == a} | {
"end_col": 36,
"end_line": 151,
"start_col": 2,
"start_line": 137
} |
Prims.Tot | val update_multi_224: Hacl.Hash.Definitions.update_multi_st (|SHA2_224, ()|) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n | val update_multi_224: Hacl.Hash.Definitions.update_multi_st (|SHA2_224, ()|)
let update_multi_224 s ev blocks n = | false | null | false | assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.Hash.Definitions.extra_state",
"Hacl.Hash.Definitions.get_alg",
"Hacl.Hash.Definitions.blocks_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"Lib.IntTypes.uint8",
"LowStar.Buffer.trivial_preorder",
"FStar.Mul.op_Star",
"Spec.Hash.Definitions.block_length",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"EverCrypt.Hash.update_multi_256",
"Prims.unit",
"Spec.SHA2.Lemmas.update_multi_224_256",
"LowStar.Monotonic.Buffer.as_seq",
"Hacl.Hash.Definitions.impl_word",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Spec.Hash.Definitions.words_state",
"Spec.Hash.Definitions.SHA2_256"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_multi_224: Hacl.Hash.Definitions.update_multi_st (|SHA2_224, ()|) | [] | EverCrypt.Hash.update_multi_224 | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Hash.Definitions.update_multi_st (| Spec.Hash.Definitions.SHA2_224, () |) | {
"end_col": 32,
"end_line": 372,
"start_col": 2,
"start_line": 369
} |
FStar.Pervasives.Lemma | val frame_invariant: #a:alg -> l:M.loc -> s:state a -> h0:HS.mem -> h1:HS.mem -> Lemma
(requires (
invariant s h0 /\
M.loc_disjoint l (footprint s h0) /\
M.modifies l h0 h1))
(ensures (
invariant s h1 /\
repr s h0 == repr s h1)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1)) | val frame_invariant: #a:alg -> l:M.loc -> s:state a -> h0:HS.mem -> h1:HS.mem -> Lemma
(requires (
invariant s h0 /\
M.loc_disjoint l (footprint s h0) /\
M.modifies l h0 h1))
(ensures (
invariant s h1 /\
repr s h0 == repr s h1))
let frame_invariant #a l s h0 h1 = | false | null | true | let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1)) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"lemma"
] | [
"EverCrypt.Hash.alg",
"LowStar.Monotonic.Buffer.loc",
"EverCrypt.Hash.state",
"FStar.Monotonic.HyperStack.mem",
"Prims._assert",
"EverCrypt.Hash.repr_eq",
"EverCrypt.Hash.repr",
"EverCrypt.Hash.state_s",
"LowStar.Monotonic.Buffer.deref",
"LowStar.Buffer.trivial_preorder",
"Prims.unit"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = () | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val frame_invariant: #a:alg -> l:M.loc -> s:state a -> h0:HS.mem -> h1:HS.mem -> Lemma
(requires (
invariant s h0 /\
M.loc_disjoint l (footprint s h0) /\
M.modifies l h0 h1))
(ensures (
invariant s h1 /\
repr s h0 == repr s h1)) | [] | EverCrypt.Hash.frame_invariant | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
l: LowStar.Monotonic.Buffer.loc ->
s: EverCrypt.Hash.state a ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
EverCrypt.Hash.invariant s h0 /\
LowStar.Monotonic.Buffer.loc_disjoint l (EverCrypt.Hash.footprint s h0) /\
LowStar.Monotonic.Buffer.modifies l h0 h1)
(ensures EverCrypt.Hash.invariant s h1 /\ EverCrypt.Hash.repr s h0 == EverCrypt.Hash.repr s h1
) | {
"end_col": 42,
"end_line": 217,
"start_col": 34,
"start_line": 215
} |
Prims.Tot | val alg_of_state: a:e_alg -> (
let a = G.reveal a in
s: state a -> Stack alg
(fun h0 -> invariant s h0)
(fun h0 a' h1 -> h0 == h1 /\ a' == a)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B | val alg_of_state: a:e_alg -> (
let a = G.reveal a in
s: state a -> Stack alg
(fun h0 -> invariant s h0)
(fun h0 a' h1 -> h0 == h1 /\ a' == a))
let alg_of_state a s = | false | null | false | let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Spec.Hash.Definitions.SHA1",
"Spec.Hash.Definitions.SHA2_224",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Hash.Definitions.SHA2_384",
"Spec.Hash.Definitions.SHA2_512",
"Spec.Hash.Definitions.SHA3_224",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Spec.Hash.Definitions.Blake2B",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"EverCrypt.Hash.state_s",
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.BufferOps.op_Bang_Star",
"LowStar.Buffer.trivial_preorder"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s) | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alg_of_state: a:e_alg -> (
let a = G.reveal a in
s: state a -> Stack alg
(fun h0 -> invariant s h0)
(fun h0 a' h1 -> h0 == h1 /\ a' == a)) | [] | EverCrypt.Hash.alg_of_state | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: EverCrypt.Hash.e_alg
-> (let a = FStar.Ghost.reveal a in
s: EverCrypt.Hash.state a -> FStar.HyperStack.ST.Stack EverCrypt.Hash.alg) | {
"end_col": 32,
"end_line": 206,
"start_col": 2,
"start_line": 191
} |
Prims.Tot | val p (#a: _) (s: state_s a) : Hacl.Hash.Definitions.state (impl_of_state s) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p | val p (#a: _) (s: state_s a) : Hacl.Hash.Definitions.state (impl_of_state s)
let p #a (s: state_s a) : Hacl.Hash.Definitions.state (impl_of_state s) = | false | null | false | match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.fixed_len_alg",
"EverCrypt.Hash.state_s",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Spec.Hash.Definitions.SHA1",
"Spec.Hash.Definitions.SHA2_224",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Hash.Definitions.SHA2_384",
"Spec.Hash.Definitions.SHA2_512",
"Spec.Hash.Definitions.SHA3_224",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Spec.Hash.Definitions.Blake2B",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"EverCrypt.Hash.impl_of_state"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val p (#a: _) (s: state_s a) : Hacl.Hash.Definitions.state (impl_of_state s) | [] | EverCrypt.Hash.p | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: EverCrypt.Hash.state_s a -> Hacl.Hash.Definitions.state (EverCrypt.Hash.impl_of_state s) | {
"end_col": 26,
"end_line": 176,
"start_col": 2,
"start_line": 162
} |
FStar.Pervasives.Lemma | val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let modulo_sub_lemma a b c =
calc(==) {
(a - b) % c;
(==) { Math.Lemmas.lemma_mod_add_distr (-b) a c }
((a % c) - b) % c;
};
assert(- c < (a % c) - b);
assert((a % c) - b < c);
Math.Lemmas.euclidean_division_definition ((a % c) - b) c;
assert(a % c - b = ((a % c - b) / c) * c);
assert(1 * c = c);
assert((-1) * c = - c);
let d = (a % c - b) / c in
if 1 <= d then
begin
Math.Lemmas.lemma_mult_le_right c 1 d;
assert(d * c >= 1 * c);
assert(False)
end;
if d <= -1 then
begin
Math.Lemmas.lemma_mult_le_right c d (-1);
assert(d * c <= (-1) * c);
assert(d * c <= - c);
assert(False)
end;
assert(d = 0);
assert(d * c = 0);
assert(a % c - b = 0);
assert(a % c = b) | val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c))
let modulo_sub_lemma a b c = | false | null | true | calc ( == ) {
(a - b) % c;
( == ) { Math.Lemmas.lemma_mod_add_distr (- b) a c }
((a % c) - b) % c;
};
assert (- c < (a % c) - b);
assert ((a % c) - b < c);
Math.Lemmas.euclidean_division_definition ((a % c) - b) c;
assert (a % c - b = ((a % c - b) / c) * c);
assert (1 * c = c);
assert ((- 1) * c = - c);
let d = (a % c - b) / c in
if 1 <= d
then
(Math.Lemmas.lemma_mult_le_right c 1 d;
assert (d * c >= 1 * c);
assert (False));
if d <= - 1
then
(Math.Lemmas.lemma_mult_le_right c d (- 1);
assert (d * c <= (- 1) * c);
assert (d * c <= - c);
assert (False));
assert (d = 0);
assert (d * c = 0);
assert (a % c - b = 0);
assert (a % c = b) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"lemma"
] | [
"FStar.Integers.int",
"FStar.Integers.nat",
"FStar.Integers.pos",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Integers.int_t",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Integers.op_Percent",
"Prims.unit",
"Prims.int",
"FStar.Integers.op_Subtraction",
"FStar.Integers.op_Star",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.op_Minus",
"Prims.l_False",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Prims.bool",
"FStar.Integers.op_Greater_Equals",
"FStar.Integers.op_Slash",
"FStar.Math.Lemmas.euclidean_division_definition",
"FStar.Integers.op_Less",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_add_distr",
"Prims.squash"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract
let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n
#push-options "--ifuel 1"
let update_multi #a s prevlen blocks len =
match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p -> let n = len / block_len SHA3_224 in Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p -> let n = len / block_len SHA3_256 in Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p -> let n = len / block_len SHA3_384 in Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p -> let n = len / block_len SHA3_512 in Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
#pop-options
let update_last #a s prev_len last last_len =
[@inline_let] let cast = FStar.Int.Cast.Full.uint64_to_uint128 in
match !*s with
| MD5_s p ->
Hacl.Hash.MD5.legacy_update_last p prev_len last last_len
| SHA1_s p ->
Hacl.Hash.SHA1.legacy_update_last p prev_len last last_len
| SHA2_224_s p ->
Hacl.Hash.SHA2.update_last_224 p prev_len last last_len
| SHA2_256_s p ->
Hacl.Hash.SHA2.update_last_256 p prev_len last last_len
| SHA2_384_s p ->
Hacl.Hash.SHA2.update_last_384 p (cast prev_len) last last_len
| SHA2_512_s p ->
Hacl.Hash.SHA2.update_last_512 p (cast prev_len) last last_len
| SHA3_224_s p -> Hacl.Hash.SHA3.update_last SHA3_224 p () last last_len
| SHA3_256_s p -> Hacl.Hash.SHA3.update_last SHA3_256 p () last last_len
| SHA3_384_s p -> Hacl.Hash.SHA3.update_last SHA3_384 p () last last_len
| SHA3_512_s p -> Hacl.Hash.SHA3.update_last SHA3_512 p () last last_len
| Blake2S_s p ->
Hacl.Hash.Blake2.update_last_blake2s_32 p prev_len last last_len
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.update_last_blake2s_128 p prev_len last last_len
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.update_last_blake2b_32 p (cast prev_len) last last_len
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.update_last_blake2b_256 p (cast prev_len) last last_len
else LowStar.Ignore.ignore p
// TODO: move to FStar.Math.Lemmas
val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c)) | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c)) | [] | EverCrypt.Hash.modulo_sub_lemma | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: FStar.Integers.int -> b: FStar.Integers.nat -> c: FStar.Integers.pos
-> FStar.Pervasives.Lemma (requires b < c /\ (a - b) % c = 0) (ensures b = a % c) | {
"end_col": 19,
"end_line": 492,
"start_col": 2,
"start_line": 464
} |
Prims.Tot | val update_multi_256: Hacl.Hash.Definitions.update_multi_st (|SHA2_256, ()|) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n) | val update_multi_256: Hacl.Hash.Definitions.update_multi_st (|SHA2_256, ()|)
let update_multi_256 s ev blocks n = | false | null | false | if EverCrypt.TargetConfig.hacl_can_compile_vale
then
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse)
then
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
else Hacl.Hash.SHA2.update_multi_256 s () blocks n
else
(LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n) | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.Hash.Definitions.extra_state",
"Hacl.Hash.Definitions.get_alg",
"Hacl.Hash.Definitions.blocks_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"Lib.IntTypes.uint8",
"LowStar.Buffer.trivial_preorder",
"FStar.Mul.op_Star",
"Spec.Hash.Definitions.block_length",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"EverCrypt.TargetConfig.hacl_can_compile_vale",
"Prims.op_AmpAmp",
"Prims.unit",
"Vale.Wrapper.X64.Sha.sha256_update",
"EverCrypt.Hash.k224_256",
"LowStar.ImmutableBuffer.buffer_immutable_buffer_disjoint",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Hash.Definitions.impl_word",
"LowStar.ImmutableBuffer.recall_contents",
"Spec.SHA2.Constants.k224_256",
"LowStar.Monotonic.Buffer.recall",
"LowStar.ImmutableBuffer.immutable_preorder",
"FStar.UInt64.t",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt64.v",
"FStar.UInt32.v",
"FStar.Int.Cast.uint32_to_uint64",
"Prims.bool",
"Hacl.Hash.SHA2.update_multi_256",
"EverCrypt.AutoConfig2.has_sse",
"EverCrypt.AutoConfig2.has_shaext",
"LowStar.Ignore.ignore",
"LowStar.ImmutableBuffer.libuffer",
"FStar.Seq.Properties.seq_of_list",
"Spec.SHA2.Constants.k224_256_l",
"Prims.l_and",
"Prims.eq2",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.recallable"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time! | false | false | EverCrypt.Hash.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_multi_256: Hacl.Hash.Definitions.update_multi_st (|SHA2_256, ()|) | [] | EverCrypt.Hash.update_multi_256 | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Hash.Definitions.update_multi_st (| Spec.Hash.Definitions.SHA2_256, () |) | {
"end_col": 50,
"end_line": 363,
"start_col": 2,
"start_line": 346
} |
Prims.Tot | val free_:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a -> ST unit
(requires fun h0 ->
freeable h0 s /\
invariant s h0)
(ensures fun h0 _ h1 ->
M.(modifies (footprint s h0) h0 h1))) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let free_ #ea s =
begin match !*s with
| MD5_s p -> B.free p
| SHA1_s p -> B.free p
| SHA2_224_s p -> B.free p
| SHA2_256_s p -> B.free p
| SHA2_384_s p -> B.free p
| SHA2_512_s p -> B.free p
| SHA3_224_s p -> B.free p
| SHA3_256_s p -> B.free p
| SHA3_384_s p -> B.free p
| SHA3_512_s p -> B.free p
| Blake2S_s p -> B.free p
| Blake2S_128_s _ p -> B.free p
| Blake2B_s p -> B.free p
| Blake2B_256_s _ p -> B.free p
end;
B.free s | val free_:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a -> ST unit
(requires fun h0 ->
freeable h0 s /\
invariant s h0)
(ensures fun h0 _ h1 ->
M.(modifies (footprint s h0) h0 h1)))
let free_ #ea s = | false | null | false | (match !*s with
| MD5_s p -> B.free p
| SHA1_s p -> B.free p
| SHA2_224_s p -> B.free p
| SHA2_256_s p -> B.free p
| SHA2_384_s p -> B.free p
| SHA2_512_s p -> B.free p
| SHA3_224_s p -> B.free p
| SHA3_256_s p -> B.free p
| SHA3_384_s p -> B.free p
| SHA3_512_s p -> B.free p
| Blake2S_s p -> B.free p
| Blake2S_128_s _ p -> B.free p
| Blake2B_s p -> B.free p
| Blake2B_256_s _ p -> B.free p);
B.free s | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"LowStar.Monotonic.Buffer.free",
"EverCrypt.Hash.state_s",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.Definitions.impl_word",
"Spec.Hash.Definitions.SHA1",
"Spec.Hash.Definitions.SHA2_224",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Hash.Definitions.SHA2_384",
"Spec.Hash.Definitions.SHA2_512",
"Spec.Hash.Definitions.SHA3_224",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Spec.Hash.Definitions.Blake2B",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.BufferOps.op_Bang_Star"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract
let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n
#push-options "--ifuel 1"
let update_multi #a s prevlen blocks len =
match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p -> let n = len / block_len SHA3_224 in Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p -> let n = len / block_len SHA3_256 in Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p -> let n = len / block_len SHA3_384 in Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p -> let n = len / block_len SHA3_512 in Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
#pop-options
let update_last #a s prev_len last last_len =
[@inline_let] let cast = FStar.Int.Cast.Full.uint64_to_uint128 in
match !*s with
| MD5_s p ->
Hacl.Hash.MD5.legacy_update_last p prev_len last last_len
| SHA1_s p ->
Hacl.Hash.SHA1.legacy_update_last p prev_len last last_len
| SHA2_224_s p ->
Hacl.Hash.SHA2.update_last_224 p prev_len last last_len
| SHA2_256_s p ->
Hacl.Hash.SHA2.update_last_256 p prev_len last last_len
| SHA2_384_s p ->
Hacl.Hash.SHA2.update_last_384 p (cast prev_len) last last_len
| SHA2_512_s p ->
Hacl.Hash.SHA2.update_last_512 p (cast prev_len) last last_len
| SHA3_224_s p -> Hacl.Hash.SHA3.update_last SHA3_224 p () last last_len
| SHA3_256_s p -> Hacl.Hash.SHA3.update_last SHA3_256 p () last last_len
| SHA3_384_s p -> Hacl.Hash.SHA3.update_last SHA3_384 p () last last_len
| SHA3_512_s p -> Hacl.Hash.SHA3.update_last SHA3_512 p () last last_len
| Blake2S_s p ->
Hacl.Hash.Blake2.update_last_blake2s_32 p prev_len last last_len
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.update_last_blake2s_128 p prev_len last last_len
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.update_last_blake2b_32 p (cast prev_len) last last_len
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.update_last_blake2b_256 p (cast prev_len) last last_len
else LowStar.Ignore.ignore p
// TODO: move to FStar.Math.Lemmas
val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c))
let modulo_sub_lemma a b c =
calc(==) {
(a - b) % c;
(==) { Math.Lemmas.lemma_mod_add_distr (-b) a c }
((a % c) - b) % c;
};
assert(- c < (a % c) - b);
assert((a % c) - b < c);
Math.Lemmas.euclidean_division_definition ((a % c) - b) c;
assert(a % c - b = ((a % c - b) / c) * c);
assert(1 * c = c);
assert((-1) * c = - c);
let d = (a % c - b) / c in
if 1 <= d then
begin
Math.Lemmas.lemma_mult_le_right c 1 d;
assert(d * c >= 1 * c);
assert(False)
end;
if d <= -1 then
begin
Math.Lemmas.lemma_mult_le_right c d (-1);
assert(d * c <= (-1) * c);
assert(d * c <= - c);
assert(False)
end;
assert(d = 0);
assert(d * c = 0);
assert(a % c - b = 0);
assert(a % c = b)
#push-options "--ifuel 1"
let finish #a s dst =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_finish p dst
| SHA1_s p -> Hacl.Hash.SHA1.legacy_finish p dst
| SHA2_224_s p -> Hacl.Hash.SHA2.finish_224 p dst
| SHA2_256_s p -> Hacl.Hash.SHA2.finish_256 p dst
| SHA2_384_s p -> Hacl.Hash.SHA2.finish_384 p dst
| SHA2_512_s p -> Hacl.Hash.SHA2.finish_512 p dst
| SHA3_224_s p -> Hacl.Hash.SHA3.finish SHA3_224 p dst
| SHA3_256_s p -> Hacl.Hash.SHA3.finish SHA3_256 p dst
| SHA3_384_s p -> Hacl.Hash.SHA3.finish SHA3_384 p dst
| SHA3_512_s p -> Hacl.Hash.SHA3.finish SHA3_512 p dst
| Blake2S_s p -> Hacl.Hash.Blake2.finish_blake2s_32 p dst
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.finish_blake2s_128 p dst
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.finish_blake2b_32 p dst
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.finish_blake2b_256 p dst
else LowStar.Ignore.ignore p
#pop-options | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val free_:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a -> ST unit
(requires fun h0 ->
freeable h0 s /\
invariant s h0)
(ensures fun h0 _ h1 ->
M.(modifies (footprint s h0) h0 h1))) | [] | EverCrypt.Hash.free_ | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | let a = FStar.Ghost.reveal a in
s: EverCrypt.Hash.state a -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 10,
"end_line": 539,
"start_col": 2,
"start_line": 523
} |
Prims.Tot | val init: #a:e_alg -> (
let a = Ghost.reveal a in
s: state a -> Stack unit
(requires invariant s)
(ensures fun h0 _ h1 ->
invariant s h1 /\
repr s h1 == Spec.Agile.Hash.init a /\
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
preserves_freeable s h0 h1)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p | val init: #a:e_alg -> (
let a = Ghost.reveal a in
s: state a -> Stack unit
(requires invariant s)
(ensures fun h0 _ h1 ->
invariant s h1 /\
repr s h1 == Spec.Agile.Hash.init a /\
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
preserves_freeable s h0 h1))
let init #a s = | false | null | false | match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p ->
let _ = Hacl.Hash.Blake2.init_blake2s_32 p in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
let _ = Hacl.Hash.Blake2.init_blake2b_32 p in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in
()
else LowStar.Ignore.ignore p | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.Core.MD5.legacy_init",
"Prims.unit",
"Spec.Hash.Definitions.SHA1",
"Hacl.Hash.Core.SHA1.legacy_init",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.Hash.SHA2.init_224",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.Hash.SHA2.init_256",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.Hash.SHA2.init_384",
"Spec.Hash.Definitions.SHA2_512",
"Hacl.Hash.SHA2.init_512",
"Spec.Hash.Definitions.SHA3_224",
"Hacl.Hash.SHA3.init",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Blake2.init_blake2s_32",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Hash.Blake2.init_blake2s_128",
"Prims.bool",
"LowStar.Ignore.ignore",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Hash.Blake2.init_blake2b_32",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"Hacl.Hash.Blake2.init_blake2b_256",
"EverCrypt.Hash.state_s",
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.BufferOps.op_Bang_Star",
"LowStar.Buffer.trivial_preorder"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations. | false | false | EverCrypt.Hash.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val init: #a:e_alg -> (
let a = Ghost.reveal a in
s: state a -> Stack unit
(requires invariant s)
(ensures fun h0 _ h1 ->
invariant s h1 /\
repr s h1 == Spec.Agile.Hash.init a /\
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
preserves_freeable s h0 h1)) | [] | EverCrypt.Hash.init | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | let a = FStar.Ghost.reveal a in
s: EverCrypt.Hash.state a -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 34,
"end_line": 326,
"start_col": 2,
"start_line": 306
} |
FStar.HyperStack.ST.StackInline | val alloca: a:alg -> StackInline (state a)
(requires (fun _ -> True))
(ensures (fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
M.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint s h1)))) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul | val alloca: a:alg -> StackInline (state a)
(requires (fun _ -> True))
(ensures (fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
M.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint s h1))))
let alloca a = | true | null | false | let s:state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0uL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0uL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0uL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0uL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0uL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0uL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128
then
let open Hacl.Impl.Blake2.Core in
[@@ inline_let ]let i:impl = (| Blake2S, M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else Blake2S_s (B.alloca 0ul 16ul)
else Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256
then
let open Hacl.Impl.Blake2.Core in
[@@ inline_let ]let i:impl = (| Blake2B, M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else Blake2B_s (B.alloca 0uL 16ul)
else Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [] | [
"EverCrypt.Hash.alg",
"LowStar.Buffer.alloca",
"EverCrypt.Hash.state_s",
"FStar.UInt32.__uint_to_t",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"EverCrypt.Hash.MD5_s",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.Definitions.impl_word",
"EverCrypt.Hash.SHA1_s",
"Spec.Hash.Definitions.SHA1",
"EverCrypt.Hash.SHA2_224_s",
"Spec.Hash.Definitions.SHA2_224",
"EverCrypt.Hash.SHA2_256_s",
"Spec.Hash.Definitions.SHA2_256",
"EverCrypt.Hash.SHA2_384_s",
"Spec.Hash.Definitions.SHA2_384",
"FStar.UInt64.__uint_to_t",
"EverCrypt.Hash.SHA2_512_s",
"Spec.Hash.Definitions.SHA2_512",
"EverCrypt.Hash.SHA3_224_s",
"Spec.Hash.Definitions.SHA3_224",
"EverCrypt.Hash.SHA3_256_s",
"Spec.Hash.Definitions.SHA3_256",
"EverCrypt.Hash.SHA3_384_s",
"Spec.Hash.Definitions.SHA3_384",
"EverCrypt.Hash.SHA3_512_s",
"Spec.Hash.Definitions.SHA3_512",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.Hash.Blake2S_128_s",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Impl.Blake2.Core.zero_element",
"Spec.Blake2.Blake2S",
"Hacl.Hash.Definitions.impl_state_len",
"EverCrypt.Hash.impl",
"Prims.bool",
"EverCrypt.Hash.Blake2S_s",
"Hacl.Impl.Blake2.Core.M32",
"EverCrypt.AutoConfig2.has_vec128",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.Hash.Blake2B_256_s",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Impl.Blake2.Core.M256",
"Spec.Blake2.Blake2B",
"EverCrypt.Hash.Blake2B_s",
"EverCrypt.AutoConfig2.has_vec256",
"EverCrypt.Hash.state"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alloca: a:alg -> StackInline (state a)
(requires (fun _ -> True))
(ensures (fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
M.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint s h1)))) | [] | EverCrypt.Hash.alloca | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: EverCrypt.Hash.alg -> FStar.HyperStack.ST.StackInline (EverCrypt.Hash.state a) | {
"end_col": 16,
"end_line": 257,
"start_col": 14,
"start_line": 221
} |
FStar.HyperStack.ST.ST | val create_in: a:alg -> r:HS.rid -> ST (state a)
(requires (fun _ ->
HyperStack.ST.is_eternal_region r))
(ensures (fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
M.(loc_includes (loc_region_only true r) (footprint s h1)) /\
freeable h1 s)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul | val create_in: a:alg -> r:HS.rid -> ST (state a)
(requires (fun _ ->
HyperStack.ST.is_eternal_region r))
(ensures (fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
M.(loc_includes (loc_region_only true r) (footprint s h1)) /\
freeable h1 s))
let create_in a r = | true | null | false | let h0 = ST.get () in
let s:state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0uL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0uL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0uL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0uL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0uL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0uL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128
then Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else Blake2S_s (B.malloc r 0ul 16ul)
else Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256
then Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else Blake2B_s (B.malloc r 0uL 16ul)
else Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [] | [
"EverCrypt.Hash.alg",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Buffer.malloc",
"EverCrypt.Hash.state_s",
"FStar.UInt32.__uint_to_t",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.freeable",
"EverCrypt.Hash.MD5_s",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.Definitions.impl_word",
"EverCrypt.Hash.SHA1_s",
"Spec.Hash.Definitions.SHA1",
"EverCrypt.Hash.SHA2_224_s",
"Spec.Hash.Definitions.SHA2_224",
"EverCrypt.Hash.SHA2_256_s",
"Spec.Hash.Definitions.SHA2_256",
"EverCrypt.Hash.SHA2_384_s",
"Spec.Hash.Definitions.SHA2_384",
"FStar.UInt64.__uint_to_t",
"EverCrypt.Hash.SHA2_512_s",
"Spec.Hash.Definitions.SHA2_512",
"EverCrypt.Hash.SHA3_224_s",
"Spec.Hash.Definitions.SHA3_224",
"EverCrypt.Hash.SHA3_256_s",
"Spec.Hash.Definitions.SHA3_256",
"EverCrypt.Hash.SHA3_384_s",
"Spec.Hash.Definitions.SHA3_384",
"EverCrypt.Hash.SHA3_512_s",
"Spec.Hash.Definitions.SHA3_512",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.Hash.Blake2S_128_s",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Blake2s_128.blake2s_malloc",
"Hacl.Impl.Blake2.Core.state_p",
"Spec.Blake2.Blake2S",
"Prims.bool",
"EverCrypt.Hash.Blake2S_s",
"Hacl.Impl.Blake2.Core.M32",
"EverCrypt.AutoConfig2.has_vec128",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.Hash.Blake2B_256_s",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Impl.Blake2.Core.M256",
"Hacl.Blake2b_256.blake2b_malloc",
"Spec.Blake2.Blake2B",
"EverCrypt.Hash.Blake2B_s",
"EverCrypt.AutoConfig2.has_vec256",
"EverCrypt.Hash.state",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val create_in: a:alg -> r:HS.rid -> ST (state a)
(requires (fun _ ->
HyperStack.ST.is_eternal_region r))
(ensures (fun h0 s h1 ->
invariant s h1 /\
M.(modifies loc_none h0 h1) /\
B.fresh_loc (footprint s h1) h0 h1 /\
M.(loc_includes (loc_region_only true r) (footprint s h1)) /\
freeable h1 s)) | [] | EverCrypt.Hash.create_in | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: EverCrypt.Hash.alg -> r: FStar.Monotonic.HyperHeap.rid
-> FStar.HyperStack.ST.ST (EverCrypt.Hash.state a) | {
"end_col": 18,
"end_line": 295,
"start_col": 19,
"start_line": 260
} |
Prims.Tot | val update_last:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
prev_len:uint64_t ->
last:B.buffer Lib.IntTypes.uint8 { B.length last <= block_length a } ->
last_len:uint32_t {
v last_len = B.length last /\
(v prev_len + v last_len) `less_than_max_input_length` a /\
v prev_len % block_length a = 0 } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 last /\
Spec.Agile.Hash.update_multi_pre a (ev_of_uint64 a prev_len) (B.as_seq h0 last) /\
M.(loc_disjoint (footprint s h0) (loc_buffer last)))
(ensures fun h0 _ h1 ->
invariant s h1 /\
repr s h1 ==
Spec.Hash.Incremental.update_last a (repr s h0) (prev_len_of_uint64 a prev_len)
(B.as_seq h0 last) /\
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
preserves_freeable s h0 h1)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_last #a s prev_len last last_len =
[@inline_let] let cast = FStar.Int.Cast.Full.uint64_to_uint128 in
match !*s with
| MD5_s p ->
Hacl.Hash.MD5.legacy_update_last p prev_len last last_len
| SHA1_s p ->
Hacl.Hash.SHA1.legacy_update_last p prev_len last last_len
| SHA2_224_s p ->
Hacl.Hash.SHA2.update_last_224 p prev_len last last_len
| SHA2_256_s p ->
Hacl.Hash.SHA2.update_last_256 p prev_len last last_len
| SHA2_384_s p ->
Hacl.Hash.SHA2.update_last_384 p (cast prev_len) last last_len
| SHA2_512_s p ->
Hacl.Hash.SHA2.update_last_512 p (cast prev_len) last last_len
| SHA3_224_s p -> Hacl.Hash.SHA3.update_last SHA3_224 p () last last_len
| SHA3_256_s p -> Hacl.Hash.SHA3.update_last SHA3_256 p () last last_len
| SHA3_384_s p -> Hacl.Hash.SHA3.update_last SHA3_384 p () last last_len
| SHA3_512_s p -> Hacl.Hash.SHA3.update_last SHA3_512 p () last last_len
| Blake2S_s p ->
Hacl.Hash.Blake2.update_last_blake2s_32 p prev_len last last_len
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.update_last_blake2s_128 p prev_len last last_len
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.update_last_blake2b_32 p (cast prev_len) last last_len
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.update_last_blake2b_256 p (cast prev_len) last last_len
else LowStar.Ignore.ignore p | val update_last:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
prev_len:uint64_t ->
last:B.buffer Lib.IntTypes.uint8 { B.length last <= block_length a } ->
last_len:uint32_t {
v last_len = B.length last /\
(v prev_len + v last_len) `less_than_max_input_length` a /\
v prev_len % block_length a = 0 } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 last /\
Spec.Agile.Hash.update_multi_pre a (ev_of_uint64 a prev_len) (B.as_seq h0 last) /\
M.(loc_disjoint (footprint s h0) (loc_buffer last)))
(ensures fun h0 _ h1 ->
invariant s h1 /\
repr s h1 ==
Spec.Hash.Incremental.update_last a (repr s h0) (prev_len_of_uint64 a prev_len)
(B.as_seq h0 last) /\
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
preserves_freeable s h0 h1))
let update_last #a s prev_len last last_len = | false | null | false | [@@ inline_let ]let cast = FStar.Int.Cast.Full.uint64_to_uint128 in
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_update_last p prev_len last last_len
| SHA1_s p -> Hacl.Hash.SHA1.legacy_update_last p prev_len last last_len
| SHA2_224_s p -> Hacl.Hash.SHA2.update_last_224 p prev_len last last_len
| SHA2_256_s p -> Hacl.Hash.SHA2.update_last_256 p prev_len last last_len
| SHA2_384_s p -> Hacl.Hash.SHA2.update_last_384 p (cast prev_len) last last_len
| SHA2_512_s p -> Hacl.Hash.SHA2.update_last_512 p (cast prev_len) last last_len
| SHA3_224_s p -> Hacl.Hash.SHA3.update_last SHA3_224 p () last last_len
| SHA3_256_s p -> Hacl.Hash.SHA3.update_last SHA3_256 p () last last_len
| SHA3_384_s p -> Hacl.Hash.SHA3.update_last SHA3_384 p () last last_len
| SHA3_512_s p -> Hacl.Hash.SHA3.update_last SHA3_512 p () last last_len
| Blake2S_s p -> Hacl.Hash.Blake2.update_last_blake2s_32 p prev_len last last_len
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then Hacl.Hash.Blake2.update_last_blake2s_128 p prev_len last last_len
else LowStar.Ignore.ignore p
| Blake2B_s p -> Hacl.Hash.Blake2.update_last_blake2b_32 p (cast prev_len) last last_len
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then Hacl.Hash.Blake2.update_last_blake2b_256 p (cast prev_len) last last_len
else LowStar.Ignore.ignore p | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"EverCrypt.Helpers.uint64_t",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"Prims.b2t",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Spec.Hash.Definitions.block_length",
"EverCrypt.Helpers.uint32_t",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.within_bounds",
"FStar.Integers.Unsigned",
"FStar.Integers.W32",
"FStar.Integers.v",
"Spec.Hash.Definitions.less_than_max_input_length",
"FStar.Integers.op_Plus",
"FStar.Integers.W64",
"FStar.Integers.op_Percent",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.MD5.legacy_update_last",
"Prims.unit",
"Spec.Hash.Definitions.SHA1",
"Hacl.Hash.SHA1.legacy_update_last",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.Hash.SHA2.update_last_224",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.Hash.SHA2.update_last_256",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.Hash.SHA2.update_last_384",
"Spec.Hash.Definitions.SHA2_512",
"Hacl.Hash.SHA2.update_last_512",
"Spec.Hash.Definitions.SHA3_224",
"Hacl.Hash.SHA3.update_last",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Blake2.update_last_blake2s_32",
"Prims.squash",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Hash.Blake2.update_last_blake2s_128",
"Prims.bool",
"LowStar.Ignore.ignore",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Hash.Blake2.update_last_blake2b_32",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"Hacl.Hash.Blake2.update_last_blake2b_256",
"EverCrypt.Hash.state_s",
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.BufferOps.op_Bang_Star",
"FStar.UInt64.t",
"FStar.UInt128.t",
"Prims.eq2",
"FStar.UInt.size",
"FStar.UInt128.n",
"FStar.UInt128.v",
"FStar.UInt64.v",
"FStar.Int.Cast.Full.uint64_to_uint128"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract
let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n
#push-options "--ifuel 1"
let update_multi #a s prevlen blocks len =
match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p -> let n = len / block_len SHA3_224 in Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p -> let n = len / block_len SHA3_256 in Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p -> let n = len / block_len SHA3_384 in Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p -> let n = len / block_len SHA3_512 in Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
#pop-options | false | false | EverCrypt.Hash.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_last:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
prev_len:uint64_t ->
last:B.buffer Lib.IntTypes.uint8 { B.length last <= block_length a } ->
last_len:uint32_t {
v last_len = B.length last /\
(v prev_len + v last_len) `less_than_max_input_length` a /\
v prev_len % block_length a = 0 } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 last /\
Spec.Agile.Hash.update_multi_pre a (ev_of_uint64 a prev_len) (B.as_seq h0 last) /\
M.(loc_disjoint (footprint s h0) (loc_buffer last)))
(ensures fun h0 _ h1 ->
invariant s h1 /\
repr s h1 ==
Spec.Hash.Incremental.update_last a (repr s h0) (prev_len_of_uint64 a prev_len)
(B.as_seq h0 last) /\
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
preserves_freeable s h0 h1)) | [] | EverCrypt.Hash.update_last | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | let a = FStar.Ghost.reveal a in
s: EverCrypt.Hash.state a ->
prev_len: EverCrypt.Helpers.uint64_t ->
last:
LowStar.Buffer.buffer Lib.IntTypes.uint8
{LowStar.Monotonic.Buffer.length last <= Spec.Hash.Definitions.block_length a} ->
last_len:
EverCrypt.Helpers.uint32_t
{ FStar.Integers.v last_len = LowStar.Monotonic.Buffer.length last /\
Spec.Hash.Definitions.less_than_max_input_length (FStar.Integers.v prev_len +
FStar.Integers.v last_len)
a /\ FStar.Integers.v prev_len % Spec.Hash.Definitions.block_length a = 0 }
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 34,
"end_line": 456,
"start_col": 2,
"start_line": 427
} |
Prims.Tot | val finish:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
dst:B.buffer Lib.IntTypes.uint8 { B.length dst = hash_length a } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 dst /\
M.(loc_disjoint (footprint s h0) (loc_buffer dst)))
(ensures fun h0 _ h1 ->
invariant s h1 /\
M.(modifies (loc_buffer dst `loc_union` footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
(* The 0UL value is dummy: it is actually useless *)
B.as_seq h1 dst == Spec.Agile.Hash.finish a (repr s h0) () /\
preserves_freeable s h0 h1)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finish #a s dst =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_finish p dst
| SHA1_s p -> Hacl.Hash.SHA1.legacy_finish p dst
| SHA2_224_s p -> Hacl.Hash.SHA2.finish_224 p dst
| SHA2_256_s p -> Hacl.Hash.SHA2.finish_256 p dst
| SHA2_384_s p -> Hacl.Hash.SHA2.finish_384 p dst
| SHA2_512_s p -> Hacl.Hash.SHA2.finish_512 p dst
| SHA3_224_s p -> Hacl.Hash.SHA3.finish SHA3_224 p dst
| SHA3_256_s p -> Hacl.Hash.SHA3.finish SHA3_256 p dst
| SHA3_384_s p -> Hacl.Hash.SHA3.finish SHA3_384 p dst
| SHA3_512_s p -> Hacl.Hash.SHA3.finish SHA3_512 p dst
| Blake2S_s p -> Hacl.Hash.Blake2.finish_blake2s_32 p dst
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.finish_blake2s_128 p dst
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.finish_blake2b_32 p dst
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.finish_blake2b_256 p dst
else LowStar.Ignore.ignore p | val finish:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
dst:B.buffer Lib.IntTypes.uint8 { B.length dst = hash_length a } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 dst /\
M.(loc_disjoint (footprint s h0) (loc_buffer dst)))
(ensures fun h0 _ h1 ->
invariant s h1 /\
M.(modifies (loc_buffer dst `loc_union` footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
(* The 0UL value is dummy: it is actually useless *)
B.as_seq h1 dst == Spec.Agile.Hash.finish a (repr s h0) () /\
preserves_freeable s h0 h1))
let finish #a s dst = | false | null | false | match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_finish p dst
| SHA1_s p -> Hacl.Hash.SHA1.legacy_finish p dst
| SHA2_224_s p -> Hacl.Hash.SHA2.finish_224 p dst
| SHA2_256_s p -> Hacl.Hash.SHA2.finish_256 p dst
| SHA2_384_s p -> Hacl.Hash.SHA2.finish_384 p dst
| SHA2_512_s p -> Hacl.Hash.SHA2.finish_512 p dst
| SHA3_224_s p -> Hacl.Hash.SHA3.finish SHA3_224 p dst
| SHA3_256_s p -> Hacl.Hash.SHA3.finish SHA3_256 p dst
| SHA3_384_s p -> Hacl.Hash.SHA3.finish SHA3_384 p dst
| SHA3_512_s p -> Hacl.Hash.SHA3.finish SHA3_512 p dst
| Blake2S_s p -> Hacl.Hash.Blake2.finish_blake2s_32 p dst
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then Hacl.Hash.Blake2.finish_blake2s_128 p dst
else LowStar.Ignore.ignore p
| Blake2B_s p -> Hacl.Hash.Blake2.finish_blake2b_32 p dst
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then Hacl.Hash.Blake2.finish_blake2b_256 p dst
else LowStar.Ignore.ignore p | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Spec.Hash.Definitions.hash_length",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.Core.MD5.legacy_finish",
"Prims.unit",
"Spec.Hash.Definitions.SHA1",
"Hacl.Hash.Core.SHA1.legacy_finish",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.Hash.SHA2.finish_224",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.Hash.SHA2.finish_256",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.Hash.SHA2.finish_384",
"Spec.Hash.Definitions.SHA2_512",
"Hacl.Hash.SHA2.finish_512",
"Spec.Hash.Definitions.SHA3_224",
"Hacl.Hash.SHA3.finish",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Blake2.finish_blake2s_32",
"Prims.squash",
"Prims.l_and",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Hash.Blake2.finish_blake2s_128",
"Prims.bool",
"LowStar.Ignore.ignore",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Hash.Blake2.finish_blake2b_32",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"Hacl.Hash.Blake2.finish_blake2b_256",
"EverCrypt.Hash.state_s",
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.BufferOps.op_Bang_Star"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract
let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n
#push-options "--ifuel 1"
let update_multi #a s prevlen blocks len =
match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p -> let n = len / block_len SHA3_224 in Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p -> let n = len / block_len SHA3_256 in Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p -> let n = len / block_len SHA3_384 in Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p -> let n = len / block_len SHA3_512 in Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
#pop-options
let update_last #a s prev_len last last_len =
[@inline_let] let cast = FStar.Int.Cast.Full.uint64_to_uint128 in
match !*s with
| MD5_s p ->
Hacl.Hash.MD5.legacy_update_last p prev_len last last_len
| SHA1_s p ->
Hacl.Hash.SHA1.legacy_update_last p prev_len last last_len
| SHA2_224_s p ->
Hacl.Hash.SHA2.update_last_224 p prev_len last last_len
| SHA2_256_s p ->
Hacl.Hash.SHA2.update_last_256 p prev_len last last_len
| SHA2_384_s p ->
Hacl.Hash.SHA2.update_last_384 p (cast prev_len) last last_len
| SHA2_512_s p ->
Hacl.Hash.SHA2.update_last_512 p (cast prev_len) last last_len
| SHA3_224_s p -> Hacl.Hash.SHA3.update_last SHA3_224 p () last last_len
| SHA3_256_s p -> Hacl.Hash.SHA3.update_last SHA3_256 p () last last_len
| SHA3_384_s p -> Hacl.Hash.SHA3.update_last SHA3_384 p () last last_len
| SHA3_512_s p -> Hacl.Hash.SHA3.update_last SHA3_512 p () last last_len
| Blake2S_s p ->
Hacl.Hash.Blake2.update_last_blake2s_32 p prev_len last last_len
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.update_last_blake2s_128 p prev_len last last_len
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.update_last_blake2b_32 p (cast prev_len) last last_len
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.update_last_blake2b_256 p (cast prev_len) last last_len
else LowStar.Ignore.ignore p
// TODO: move to FStar.Math.Lemmas
val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c))
let modulo_sub_lemma a b c =
calc(==) {
(a - b) % c;
(==) { Math.Lemmas.lemma_mod_add_distr (-b) a c }
((a % c) - b) % c;
};
assert(- c < (a % c) - b);
assert((a % c) - b < c);
Math.Lemmas.euclidean_division_definition ((a % c) - b) c;
assert(a % c - b = ((a % c - b) / c) * c);
assert(1 * c = c);
assert((-1) * c = - c);
let d = (a % c - b) / c in
if 1 <= d then
begin
Math.Lemmas.lemma_mult_le_right c 1 d;
assert(d * c >= 1 * c);
assert(False)
end;
if d <= -1 then
begin
Math.Lemmas.lemma_mult_le_right c d (-1);
assert(d * c <= (-1) * c);
assert(d * c <= - c);
assert(False)
end;
assert(d = 0);
assert(d * c = 0);
assert(a % c - b = 0);
assert(a % c = b)
#push-options "--ifuel 1" | false | false | EverCrypt.Hash.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finish:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
dst:B.buffer Lib.IntTypes.uint8 { B.length dst = hash_length a } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 dst /\
M.(loc_disjoint (footprint s h0) (loc_buffer dst)))
(ensures fun h0 _ h1 ->
invariant s h1 /\
M.(modifies (loc_buffer dst `loc_union` footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
(* The 0UL value is dummy: it is actually useless *)
B.as_seq h1 dst == Spec.Agile.Hash.finish a (repr s h0) () /\
preserves_freeable s h0 h1)) | [] | EverCrypt.Hash.finish | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | let a = FStar.Ghost.reveal a in
s: EverCrypt.Hash.state a ->
dst:
LowStar.Buffer.buffer Lib.IntTypes.uint8
{LowStar.Monotonic.Buffer.length dst = Spec.Hash.Definitions.hash_length a}
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 34,
"end_line": 518,
"start_col": 2,
"start_line": 497
} |
Prims.Tot | val update_multi:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
prevlen : uint64_t { UInt64.v prevlen % block_length a = 0 } ->
blocks:B.buffer Lib.IntTypes.uint8 { B.length blocks % block_length a = 0 } ->
len: UInt32.t { v len = B.length blocks } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 blocks /\
Spec.Agile.Hash.update_multi_pre a (ev_of_uint64 a prevlen) (B.as_seq h0 blocks) /\
M.(loc_disjoint (footprint s h0) (loc_buffer blocks)))
(ensures fun h0 _ h1 ->
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
invariant s h1 /\
repr s h1 == Spec.Agile.Hash.update_multi a (repr s h0)
(ev_of_uint64 a prevlen) (B.as_seq h0 blocks) /\
preserves_freeable s h0 h1)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_multi #a s prevlen blocks len =
match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p -> let n = len / block_len SHA3_224 in Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p -> let n = len / block_len SHA3_256 in Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p -> let n = len / block_len SHA3_384 in Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p -> let n = len / block_len SHA3_512 in Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p | val update_multi:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
prevlen : uint64_t { UInt64.v prevlen % block_length a = 0 } ->
blocks:B.buffer Lib.IntTypes.uint8 { B.length blocks % block_length a = 0 } ->
len: UInt32.t { v len = B.length blocks } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 blocks /\
Spec.Agile.Hash.update_multi_pre a (ev_of_uint64 a prevlen) (B.as_seq h0 blocks) /\
M.(loc_disjoint (footprint s h0) (loc_buffer blocks)))
(ensures fun h0 _ h1 ->
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
invariant s h1 /\
repr s h1 == Spec.Agile.Hash.update_multi a (repr s h0)
(ev_of_uint64 a prevlen) (B.as_seq h0 blocks) /\
preserves_freeable s h0 h1))
let update_multi #a s prevlen blocks len = | false | null | false | match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p ->
let n = len / block_len SHA3_224 in
Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p ->
let n = len / block_len SHA3_256 in
Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p ->
let n = len / block_len SHA3_384 in
Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p ->
let n = len / block_len SHA3_512 in
Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@@ inline_let ]let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then
[@@ inline_let ]let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"EverCrypt.Helpers.uint64_t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Integers.op_Percent",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.UInt64.v",
"Spec.Hash.Definitions.block_length",
"LowStar.Buffer.buffer",
"Lib.IntTypes.uint8",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.l_or",
"FStar.Integers.within_bounds",
"FStar.Integers.Unsigned",
"FStar.Integers.W32",
"Prims.op_GreaterThanOrEqual",
"FStar.Integers.v",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"Hacl.Hash.MD5.legacy_update_multi",
"Prims.unit",
"FStar.Integers.int_t",
"FStar.Integers.op_Slash",
"Hacl.Hash.Definitions.block_len",
"Spec.Hash.Definitions.SHA1",
"Hacl.Hash.SHA1.legacy_update_multi",
"Spec.Hash.Definitions.SHA2_224",
"EverCrypt.Hash.update_multi_224",
"Spec.Hash.Definitions.SHA2_256",
"EverCrypt.Hash.update_multi_256",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.Hash.SHA2.update_multi_384",
"Spec.Hash.Definitions.SHA2_512",
"Hacl.Hash.SHA2.update_multi_512",
"Spec.Hash.Definitions.SHA3_224",
"Hacl.Hash.SHA3.update_multi",
"Spec.Hash.Definitions.SHA3_256",
"Spec.Hash.Definitions.SHA3_384",
"Spec.Hash.Definitions.SHA3_512",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Hacl.Hash.Blake2.update_multi_blake2s_32",
"Prims.squash",
"Prims.l_and",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Hash.Blake2.update_multi_blake2s_128",
"Prims.bool",
"LowStar.Ignore.ignore",
"Spec.Hash.Definitions.Blake2B",
"Hacl.Hash.Blake2.update_multi_blake2b_32",
"FStar.UInt128.t",
"Prims.eq2",
"FStar.UInt.size",
"FStar.UInt128.n",
"FStar.UInt128.v",
"FStar.Int.Cast.Full.uint64_to_uint128",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"Hacl.Hash.Blake2.update_multi_blake2b_256",
"EverCrypt.Hash.state_s",
"Spec.Hash.Definitions.fixed_len_alg",
"LowStar.BufferOps.op_Bang_Star"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract
let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n
#push-options "--ifuel 1" | false | false | EverCrypt.Hash.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_multi:
#a:e_alg -> (
let a = Ghost.reveal a in
s:state a ->
prevlen : uint64_t { UInt64.v prevlen % block_length a = 0 } ->
blocks:B.buffer Lib.IntTypes.uint8 { B.length blocks % block_length a = 0 } ->
len: UInt32.t { v len = B.length blocks } ->
Stack unit
(requires fun h0 ->
invariant s h0 /\
B.live h0 blocks /\
Spec.Agile.Hash.update_multi_pre a (ev_of_uint64 a prevlen) (B.as_seq h0 blocks) /\
M.(loc_disjoint (footprint s h0) (loc_buffer blocks)))
(ensures fun h0 _ h1 ->
M.(modifies (footprint s h0) h0 h1) /\
footprint s h0 == footprint s h1 /\
invariant s h1 /\
repr s h1 == Spec.Agile.Hash.update_multi a (repr s h0)
(ev_of_uint64 a prevlen) (B.as_seq h0 blocks) /\
preserves_freeable s h0 h1)) | [] | EverCrypt.Hash.update_multi | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | let a = FStar.Ghost.reveal a in
s: EverCrypt.Hash.state a ->
prevlen:
EverCrypt.Helpers.uint64_t{FStar.UInt64.v prevlen % Spec.Hash.Definitions.block_length a = 0} ->
blocks:
LowStar.Buffer.buffer Lib.IntTypes.uint8
{LowStar.Monotonic.Buffer.length blocks % Spec.Hash.Definitions.block_length a = 0} ->
len: FStar.UInt32.t{FStar.Integers.v len = LowStar.Monotonic.Buffer.length blocks}
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 34,
"end_line": 422,
"start_col": 2,
"start_line": 378
} |
Prims.Tot | val copy:
#a:e_alg -> (
let a = Ghost.reveal a in
s_src:state a ->
s_dst:state a ->
Stack unit
(requires (fun h0 ->
invariant s_src h0 /\
invariant s_dst h0 /\
B.(loc_disjoint (footprint s_src h0) (footprint s_dst h0))))
(ensures fun h0 _ h1 ->
M.(modifies (footprint s_dst h0) h0 h1) /\
footprint s_dst h0 == footprint s_dst h1 /\
preserves_freeable s_dst h0 h1 /\
invariant s_dst h1 /\
repr s_dst h1 == repr s_src h0)) | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "C.Failure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "EverCrypt.AutoConfig2",
"short_module": "AC"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "IB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let copy #a s_src s_dst =
match !*s_src with
| MD5_s p_src ->
[@inline_let]
let s_dst: state MD5 = s_dst in
let p_dst = MD5_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 4ul
| SHA1_s p_src ->
[@inline_let]
let s_dst: state SHA1 = s_dst in
let p_dst = SHA1_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 5ul
| SHA2_224_s p_src ->
[@inline_let]
let s_dst: state SHA2_224 = s_dst in
let p_dst = SHA2_224_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA2_256_s p_src ->
[@inline_let]
let s_dst: state SHA2_256 = s_dst in
let p_dst = SHA2_256_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA2_384_s p_src ->
[@inline_let]
let s_dst: state SHA2_384 = s_dst in
let p_dst = SHA2_384_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA2_512_s p_src ->
[@inline_let]
let s_dst: state SHA2_512 = s_dst in
let p_dst = SHA2_512_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA3_224_s p_src ->
[@inline_let] let s_dst: state SHA3_224 = s_dst in
let p_dst = SHA3_224_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| SHA3_256_s p_src ->
[@inline_let] let s_dst: state SHA3_256 = s_dst in
let p_dst = SHA3_256_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| SHA3_384_s p_src ->
[@inline_let] let s_dst: state SHA3_384 = s_dst in
let p_dst = SHA3_384_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| SHA3_512_s p_src ->
[@inline_let] let s_dst: state SHA3_512 = s_dst in
let p_dst = SHA3_512_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| Blake2S_s p_src ->
begin match !*s_dst with
| Blake2S_s p_dst ->
[@inline_let]
let s_dst: state Blake2S = s_dst in
B.blit p_src 0ul p_dst 0ul 16ul
| Blake2S_128_s _ p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
[@inline_let]
let s_dst: state Blake2S = s_dst in
Hacl.Blake2s_128.load_state128s_from_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst
end
| Blake2B_s p_src ->
begin match !*s_dst with
| Blake2B_s p_dst ->
[@inline_let]
let s_dst: state Blake2B = s_dst in
B.blit p_src 0ul p_dst 0ul 16ul
| Blake2B_256_s _ p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let]
let s_dst: state Blake2B = s_dst in
Hacl.Blake2b_256.load_state256b_from_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst
end
| Blake2S_128_s _ p_src ->
begin match !*s_dst with
| Blake2S_128_s _ p_dst ->
[@inline_let]
let s_dst: state Blake2S = s_dst in
B.blit p_src 0ul p_dst 0ul 4ul
| Blake2S_s p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
[@inline_let]
let s_dst: state Blake2S = s_dst in
Hacl.Blake2s_128.store_state128s_to_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst
end
| Blake2B_256_s _ p_src ->
begin match !*s_dst with
| Blake2B_256_s _ p_dst ->
[@inline_let]
let s_dst: state Blake2B = s_dst in
B.blit p_src 0ul p_dst 0ul 4ul
| Blake2B_s p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let]
let s_dst: state Blake2B = s_dst in
Hacl.Blake2b_256.store_state256b_to_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst
end | val copy:
#a:e_alg -> (
let a = Ghost.reveal a in
s_src:state a ->
s_dst:state a ->
Stack unit
(requires (fun h0 ->
invariant s_src h0 /\
invariant s_dst h0 /\
B.(loc_disjoint (footprint s_src h0) (footprint s_dst h0))))
(ensures fun h0 _ h1 ->
M.(modifies (footprint s_dst h0) h0 h1) /\
footprint s_dst h0 == footprint s_dst h1 /\
preserves_freeable s_dst h0 h1 /\
invariant s_dst h1 /\
repr s_dst h1 == repr s_src h0))
let copy #a s_src s_dst = | false | null | false | match !*s_src with
| MD5_s p_src ->
[@@ inline_let ]let s_dst:state MD5 = s_dst in
let p_dst = MD5_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 4ul
| SHA1_s p_src ->
[@@ inline_let ]let s_dst:state SHA1 = s_dst in
let p_dst = SHA1_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 5ul
| SHA2_224_s p_src ->
[@@ inline_let ]let s_dst:state SHA2_224 = s_dst in
let p_dst = SHA2_224_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA2_256_s p_src ->
[@@ inline_let ]let s_dst:state SHA2_256 = s_dst in
let p_dst = SHA2_256_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA2_384_s p_src ->
[@@ inline_let ]let s_dst:state SHA2_384 = s_dst in
let p_dst = SHA2_384_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA2_512_s p_src ->
[@@ inline_let ]let s_dst:state SHA2_512 = s_dst in
let p_dst = SHA2_512_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 8ul
| SHA3_224_s p_src ->
[@@ inline_let ]let s_dst:state SHA3_224 = s_dst in
let p_dst = SHA3_224_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| SHA3_256_s p_src ->
[@@ inline_let ]let s_dst:state SHA3_256 = s_dst in
let p_dst = SHA3_256_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| SHA3_384_s p_src ->
[@@ inline_let ]let s_dst:state SHA3_384 = s_dst in
let p_dst = SHA3_384_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| SHA3_512_s p_src ->
[@@ inline_let ]let s_dst:state SHA3_512 = s_dst in
let p_dst = SHA3_512_s?.p !*s_dst in
B.blit p_src 0ul p_dst 0ul 25ul
| Blake2S_s p_src ->
(match !*s_dst with
| Blake2S_s p_dst ->
[@@ inline_let ]let s_dst:state Blake2S = s_dst in
B.blit p_src 0ul p_dst 0ul 16ul
| Blake2S_128_s _ p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then
[@@ inline_let ]let s_dst:state Blake2S = s_dst in
Hacl.Blake2s_128.load_state128s_from_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst)
| Blake2B_s p_src ->
(match !*s_dst with
| Blake2B_s p_dst ->
[@@ inline_let ]let s_dst:state Blake2B = s_dst in
B.blit p_src 0ul p_dst 0ul 16ul
| Blake2B_256_s _ p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then
[@@ inline_let ]let s_dst:state Blake2B = s_dst in
Hacl.Blake2b_256.load_state256b_from_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst)
| Blake2S_128_s _ p_src ->
(match !*s_dst with
| Blake2S_128_s _ p_dst ->
[@@ inline_let ]let s_dst:state Blake2S = s_dst in
B.blit p_src 0ul p_dst 0ul 4ul
| Blake2S_s p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128
then
[@@ inline_let ]let s_dst:state Blake2S = s_dst in
Hacl.Blake2s_128.store_state128s_to_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst)
| Blake2B_256_s _ p_src ->
match !*s_dst with
| Blake2B_256_s _ p_dst ->
[@@ inline_let ]let s_dst:state Blake2B = s_dst in
B.blit p_src 0ul p_dst 0ul 4ul
| Blake2B_s p_dst ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256
then
[@@ inline_let ]let s_dst:state Blake2B = s_dst in
Hacl.Blake2b_256.store_state256b_to_state32 p_dst p_src
else LowStar.Ignore.ignore p_dst | {
"checked_file": "EverCrypt.Hash.fst.checked",
"dependencies": [
"Vale.Wrapper.X64.Sha.fsti.checked",
"Vale.SHA.SHA_helpers.fst.checked",
"Spec.SHA2.Lemmas.fsti.checked",
"Spec.SHA2.Constants.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Hash.SHA3.fsti.checked",
"Hacl.Hash.SHA2.fsti.checked",
"Hacl.Hash.SHA1.fsti.checked",
"Hacl.Hash.MD5.fsti.checked",
"Hacl.Hash.Definitions.fst.checked",
"Hacl.Hash.Blake2.fsti.checked",
"Hacl.Blake2s_128.fst.checked",
"Hacl.Blake2b_256.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Integers.fst.checked",
"FStar.Int.Cast.Full.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Calc.fsti.checked",
"EverCrypt.TargetConfig.fsti.checked",
"EverCrypt.AutoConfig2.fsti.checked",
"C.String.fsti.checked",
"C.Failure.fst.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Hash.fst"
} | [
"total"
] | [
"EverCrypt.Hash.e_alg",
"EverCrypt.Hash.state",
"FStar.Ghost.reveal",
"EverCrypt.Hash.alg",
"Hacl.Hash.Definitions.state",
"Prims.Mkdtuple2",
"Spec.Hash.Definitions.hash_alg",
"Hacl.Hash.Definitions.m_spec",
"Spec.Hash.Definitions.MD5",
"LowStar.Monotonic.Buffer.blit",
"Hacl.Hash.Definitions.impl_word",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"EverCrypt.Hash.__proj__MD5_s__item__p",
"EverCrypt.Hash.state_s",
"Prims.b2t",
"EverCrypt.Hash.uu___is_MD5_s",
"LowStar.BufferOps.op_Bang_Star",
"Spec.Hash.Definitions.SHA1",
"EverCrypt.Hash.__proj__SHA1_s__item__p",
"EverCrypt.Hash.uu___is_SHA1_s",
"Spec.Hash.Definitions.SHA2_224",
"EverCrypt.Hash.__proj__SHA2_224_s__item__p",
"EverCrypt.Hash.uu___is_SHA2_224_s",
"Spec.Hash.Definitions.SHA2_256",
"EverCrypt.Hash.__proj__SHA2_256_s__item__p",
"EverCrypt.Hash.uu___is_SHA2_256_s",
"Spec.Hash.Definitions.SHA2_384",
"EverCrypt.Hash.__proj__SHA2_384_s__item__p",
"EverCrypt.Hash.uu___is_SHA2_384_s",
"Spec.Hash.Definitions.SHA2_512",
"EverCrypt.Hash.__proj__SHA2_512_s__item__p",
"EverCrypt.Hash.uu___is_SHA2_512_s",
"Spec.Hash.Definitions.SHA3_224",
"EverCrypt.Hash.__proj__SHA3_224_s__item__p",
"EverCrypt.Hash.uu___is_SHA3_224_s",
"Spec.Hash.Definitions.SHA3_256",
"EverCrypt.Hash.__proj__SHA3_256_s__item__p",
"EverCrypt.Hash.uu___is_SHA3_256_s",
"Spec.Hash.Definitions.SHA3_384",
"EverCrypt.Hash.__proj__SHA3_384_s__item__p",
"EverCrypt.Hash.uu___is_SHA3_384_s",
"Spec.Hash.Definitions.SHA3_512",
"EverCrypt.Hash.__proj__SHA3_512_s__item__p",
"EverCrypt.Hash.uu___is_SHA3_512_s",
"Spec.Hash.Definitions.Blake2S",
"Hacl.Impl.Blake2.Core.M32",
"Prims.squash",
"Prims.l_and",
"EverCrypt.TargetConfig.hacl_can_compile_vec128",
"EverCrypt.AutoConfig2.vec128_enabled",
"Hacl.Impl.Blake2.Core.M128",
"Hacl.Blake2s_128.load_state128s_from_state32",
"Prims.bool",
"LowStar.Ignore.ignore",
"Spec.Hash.Definitions.fixed_len_alg",
"Spec.Hash.Definitions.Blake2B",
"EverCrypt.TargetConfig.hacl_can_compile_vec256",
"EverCrypt.AutoConfig2.vec256_enabled",
"Hacl.Impl.Blake2.Core.M256",
"Hacl.Blake2b_256.load_state256b_from_state32",
"Hacl.Blake2s_128.store_state128s_to_state32",
"Hacl.Blake2b_256.store_state256b_to_state32"
] | [] | module EverCrypt.Hash
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
open FStar.HyperStack.ST
module B = LowStar.Buffer
module IB = LowStar.ImmutableBuffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module AC = EverCrypt.AutoConfig2
open LowStar.BufferOps
open FStar.Integers
open C.Failure
module U64 = FStar.UInt64
module U32 = FStar.UInt32
// Allow *just* the alg type to be inverted, so that the entire module can run
// with ifuel 0
let _: squash (inversion alg) = allow_inversion alg
let string_of_alg =
let open C.String in function
| MD5 -> !$"MD5"
| SHA1 -> !$"SHA1"
| SHA2_224 -> !$"SHA2_224"
| SHA2_256 -> !$"SHA2_256"
| SHA2_384 -> !$"SHA2_384"
| SHA2_512 -> !$"SHA2_512"
| SHA3_224 -> !$"SHA3_224"
| SHA3_256 -> !$"SHA3_256"
| SHA3_384 -> !$"SHA3_384"
| SHA3_512 -> !$"SHA3_512"
| Shake128 -> !$"Shake128"
| Shake256 -> !$"Shake256"
| Blake2S -> !$"Blake2S"
| Blake2B -> !$"Blake2B"
let uint32_p = B.buffer uint_32
let uint64_p = B.buffer uint_64
let is_valid_impl (i: impl) =
let open Hacl.Impl.Blake2.Core in
match i with
| (| MD5, () |)
| (| SHA1, () |)
| (| SHA2_224, () |)
| (| SHA2_256, () |)
| (| SHA2_384, () |)
| (| SHA2_512, () |)
| (| SHA3_224, () |)
| (| SHA3_256, () |)
| (| SHA3_384, () |)
| (| SHA3_512, () |)
| (| Blake2S, M32 |)
| (| Blake2S, M128 |)
| (| Blake2B, M32 |)
| (| Blake2B, M256 |) -> true
| _ -> false
let impl = i:impl { is_valid_impl i }
inline_for_extraction noextract
let md5: impl = (| MD5, () |)
inline_for_extraction noextract
let sha1: impl = (| SHA1, () |)
inline_for_extraction noextract
let sha2_224: impl = (| SHA2_224, () |)
inline_for_extraction noextract
let sha2_256: impl = (| SHA2_256, () |)
inline_for_extraction noextract
let sha2_384: impl = (| SHA2_384, () |)
inline_for_extraction noextract
let sha2_512: impl = (| SHA2_512, () |)
inline_for_extraction noextract
let sha3_224: impl = (| SHA3_224, () |)
inline_for_extraction noextract
let sha3_256: impl = (| SHA3_256, () |)
inline_for_extraction noextract
let sha3_384: impl = (| SHA3_384, () |)
inline_for_extraction noextract
let sha3_512: impl = (| SHA3_512, () |)
inline_for_extraction noextract
let blake2s_32: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2s_128: impl = (| Blake2S, Hacl.Impl.Blake2.Core.M128 |)
inline_for_extraction noextract
let blake2b_32: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M32 |)
inline_for_extraction noextract
let blake2b_256: impl = (| Blake2B, Hacl.Impl.Blake2.Core.M256 |)
inline_for_extraction noextract
let alg_of_impl (i: impl { is_valid_impl i }): alg = dfst i
// JP: This is a slightly more complicated case than for AEAD... for AEAD,
// `state_s a = i & kv a & buffer uint8`
// because no matter the /implementation/, the resulting C type for the key is
// always a pointer to bytes. Here, that's no longer true because of Blake2, so
// we need to be a little more verbose.
noeq
type state_s: alg -> Type0 =
| MD5_s: p:Hacl.Hash.Definitions.state (|MD5, ()|) -> state_s MD5
| SHA1_s: p:Hacl.Hash.Definitions.state (|SHA1, ()|) -> state_s SHA1
| SHA2_224_s: p:Hacl.Hash.Definitions.state (|SHA2_224, ()|) -> state_s SHA2_224
| SHA2_256_s: p:Hacl.Hash.Definitions.state (|SHA2_256, ()|) -> state_s SHA2_256
| SHA2_384_s: p:Hacl.Hash.Definitions.state (|SHA2_384, ()|) -> state_s SHA2_384
| SHA2_512_s: p:Hacl.Hash.Definitions.state (|SHA2_512, ()|) -> state_s SHA2_512
| SHA3_224_s: p:Hacl.Hash.Definitions.state (|SHA3_224, ()|) -> state_s SHA3_224
| SHA3_256_s: p:Hacl.Hash.Definitions.state (|SHA3_256, ()|) -> state_s SHA3_256
| SHA3_384_s: p:Hacl.Hash.Definitions.state (|SHA3_384, ()|) -> state_s SHA3_384
| SHA3_512_s: p:Hacl.Hash.Definitions.state (|SHA3_512, ()|) -> state_s SHA3_512
| Blake2S_s: p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2S
| Blake2S_128_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec128 /\
EverCrypt.AutoConfig2.vec128_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2S, Hacl.Impl.Blake2.Core.M128|) ->
state_s Blake2S
| Blake2B_s: p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M32|) -> state_s Blake2B
| Blake2B_256_s:
_:squash (EverCrypt.TargetConfig.hacl_can_compile_vec256 /\
EverCrypt.AutoConfig2.vec256_enabled) ->
p:Hacl.Hash.Definitions.state (|Blake2B, Hacl.Impl.Blake2.Core.M256|) -> state_s Blake2B
let invert_state_s (a: alg): Lemma
(requires True)
(ensures (inversion (state_s a)))
[ SMTPat (state_s a) ]
=
allow_inversion (state_s a)
[@@strict_on_arguments [1]]
inline_for_extraction
let impl_of_state #a (s: state_s a): i:impl { alg_of_impl i == a } =
match s with
| MD5_s _ -> md5
| SHA1_s _ -> sha1
| SHA2_224_s _ -> sha2_224
| SHA2_256_s _ -> sha2_256
| SHA2_384_s _ -> sha2_384
| SHA2_512_s _ -> sha2_512
| SHA3_224_s _ -> sha3_224
| SHA3_256_s _ -> sha3_256
| SHA3_384_s _ -> sha3_384
| SHA3_512_s _ -> sha3_512
| Blake2S_s _ -> blake2s_32
| Blake2S_128_s _ _ -> blake2s_128
| Blake2B_s _ -> blake2b_32
| Blake2B_256_s _ _ -> blake2b_256
// In state_s, the data type already captures what implementation we have... three
// design choices here:
// - turn state_s into a dependent pair of G.erased impl & (SHA2_s | SHA3_s |
// ...) so as not to repeat redundant information at run-time
// - hope that we can get away with returning dependent pairs only when needed.
// We're going for a third one in this module, which is more lightweight.
[@@strict_on_arguments [1]]
inline_for_extraction
let p #a (s: state_s a): Hacl.Hash.Definitions.state (impl_of_state s) =
match s with
| MD5_s p -> p
| SHA1_s p -> p
| SHA2_224_s p -> p
| SHA2_256_s p -> p
| SHA2_384_s p -> p
| SHA2_512_s p -> p
| SHA3_224_s p -> p
| SHA3_256_s p -> p
| SHA3_384_s p -> p
| SHA3_512_s p -> p
| Blake2S_s p -> p
| Blake2S_128_s _ p -> p
| Blake2B_s p -> p
| Blake2B_256_s _ p -> p
let freeable_s #a s = B.freeable (p #a s)
let footprint_s #a (s: state_s a) =
B.loc_addr_of_buffer (p s)
let invariant_s #a (s: state_s a) h =
B.live h (p s)
let repr #a s h: GTot _ =
let s = B.get h s 0 in
as_seq h (p s)
let alg_of_state a s =
let open LowStar.BufferOps in
match !*s with
| MD5_s _ -> MD5
| SHA1_s _ -> SHA1
| SHA2_224_s _ -> SHA2_224
| SHA2_256_s _ -> SHA2_256
| SHA2_384_s _ -> SHA2_384
| SHA2_512_s _ -> SHA2_512
| SHA3_224_s _ -> SHA3_224
| SHA3_256_s _ -> SHA3_256
| SHA3_384_s _ -> SHA3_384
| SHA3_512_s _ -> SHA3_512
| Blake2S_s _ -> Blake2S
| Blake2S_128_s _ _ -> Blake2S
| Blake2B_s _ -> Blake2B
| Blake2B_256_s _ _ -> Blake2B
let repr_eq (#a:alg) (r1 r2: Spec.Hash.Definitions.words_state a) =
Seq.equal r1 r2
let fresh_is_disjoint l1 l2 h0 h1 = ()
let invariant_loc_in_footprint #a s m = ()
let frame_invariant #a l s h0 h1 =
let state = B.deref h0 s in
assert (repr_eq (repr s h0) (repr s h1))
inline_for_extraction noextract
[@@strict_on_arguments [0]]
let alloca a =
let s: state_s a =
match a with
| MD5 -> MD5_s (B.alloca 0ul 4ul)
| SHA1 -> SHA1_s (B.alloca 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.alloca 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.alloca 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.alloca 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.alloca 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.alloca 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.alloca 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.alloca 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.alloca 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
if vec128 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2S , M128 |) in
Blake2S_128_s () (B.alloca (zero_element Spec.Blake2.Blake2S M128) (impl_state_len i))
else
Blake2S_s (B.alloca 0ul 16ul)
else
Blake2S_s (B.alloca 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
let open Hacl.Impl.Blake2.Core in
[@inline_let] let i: impl = (| Blake2B , M256 |) in
Blake2B_256_s () (B.alloca (zero_element Spec.Blake2.Blake2B M256) (impl_state_len i))
else
Blake2B_s (B.alloca 0uL 16ul)
else
Blake2B_s (B.alloca 0uL 16ul)
in
B.alloca s 1ul
[@@strict_on_arguments [0]]
let create_in a r =
let h0 = ST.get () in
let s: state_s a =
match a with
| MD5 -> MD5_s (B.malloc r 0ul 4ul)
| SHA1 -> SHA1_s (B.malloc r 0ul 5ul)
| SHA2_224 -> SHA2_224_s (B.malloc r 0ul 8ul)
| SHA2_256 -> SHA2_256_s (B.malloc r 0ul 8ul)
| SHA2_384 -> SHA2_384_s (B.malloc r 0UL 8ul)
| SHA2_512 -> SHA2_512_s (B.malloc r 0UL 8ul)
| SHA3_224 -> SHA3_224_s (B.malloc r 0UL 25ul)
| SHA3_256 -> SHA3_256_s (B.malloc r 0UL 25ul)
| SHA3_384 -> SHA3_384_s (B.malloc r 0UL 25ul)
| SHA3_512 -> SHA3_512_s (B.malloc r 0UL 25ul)
| Blake2S ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let vec128 = EverCrypt.AutoConfig2.has_vec128 () in
// Slightly frustrating duplication of the else-branch because we
// can't compile this using the if-and return optimization of krml.
if vec128 then
Blake2S_128_s () (Hacl.Blake2s_128.blake2s_malloc r)
else
Blake2S_s (B.malloc r 0ul 16ul)
else
Blake2S_s (B.malloc r 0ul 16ul)
| Blake2B ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let vec256 = EverCrypt.AutoConfig2.has_vec256 () in
if vec256 then
Blake2B_256_s () (Hacl.Blake2b_256.blake2b_malloc r)
else
Blake2B_s (B.malloc r 0uL 16ul)
else
Blake2B_s (B.malloc r 0uL 16ul)
in
B.malloc r s 1ul
let create a =
create_in a HS.root
#push-options "--ifuel 1"
// NOTE: HACL* does not require suitable preconditions so the squashed proofs
// that we have the right CPU flags are useless. But it's good to demonstrate
// how to do it for future reference and/or future other implementations.
let init #a s =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_init p
| SHA1_s p -> Hacl.Hash.SHA1.legacy_init p
| SHA2_224_s p -> Hacl.Hash.SHA2.init_224 p
| SHA2_256_s p -> Hacl.Hash.SHA2.init_256 p
| SHA2_384_s p -> Hacl.Hash.SHA2.init_384 p
| SHA2_512_s p -> Hacl.Hash.SHA2.init_512 p
| SHA3_224_s p -> Hacl.Hash.SHA3.init SHA3_224 p
| SHA3_256_s p -> Hacl.Hash.SHA3.init SHA3_256 p
| SHA3_384_s p -> Hacl.Hash.SHA3.init SHA3_384 p
| SHA3_512_s p -> Hacl.Hash.SHA3.init SHA3_512 p
| Blake2S_s p -> let _ = Hacl.Hash.Blake2.init_blake2s_32 p in ()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let _ = Hacl.Hash.Blake2.init_blake2s_128 p in ()
else LowStar.Ignore.ignore p
| Blake2B_s p -> let _ = Hacl.Hash.Blake2.init_blake2b_32 p in ()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
let _ = Hacl.Hash.Blake2.init_blake2b_256 p in ()
else LowStar.Ignore.ignore p
#pop-options
friend Vale.SHA.SHA_helpers
// Avoid a cross-compilation unit symbol visibility... duplicate locally.
let k224_256 =
LowStar.ImmutableBuffer.igcmalloc_of_list HS.root Spec.SHA2.Constants.k224_256_l
#push-options "--ifuel 1"
// A new switch between HACL and Vale; can be used in place of Hacl.Hash.SHA2.update_256
// NOTE: this is an old-style switch where the CPU check is done on every call
// to update_multi... this is SUBOPTIMAL. I (JP) ported this module to use a
// proper concept of /implementation/, and for the Blake2 optimized variants,
// the state is now capable of keeping a squashed proof that the CPU supports
// what is needed...
// TODO: introduce SHA2_256_Vale in the state and test for CPU instructions only
// once, at state-creation time!
let update_multi_256 s ev blocks n =
if EverCrypt.TargetConfig.hacl_can_compile_vale then begin
let has_shaext = AC.has_shaext () in
let has_sse = AC.has_sse () in
if (has_shaext && has_sse) then begin
let n = Int.Cast.Full.uint32_to_uint64 n in
B.recall k224_256;
IB.recall_contents k224_256 Spec.SHA2.Constants.k224_256;
let h1 = ST.get () in
IB.buffer_immutable_buffer_disjoint s k224_256 h1;
let h2 = ST.get () in
IB.buffer_immutable_buffer_disjoint blocks k224_256 h2;
let res = Vale.Wrapper.X64.Sha.sha256_update s blocks n k224_256 in
res
end else
Hacl.Hash.SHA2.update_multi_256 s () blocks n
end else (
LowStar.Ignore.ignore k224_256;
Hacl.Hash.SHA2.update_multi_256 s () blocks n)
#pop-options
inline_for_extraction noextract
let update_multi_224 s ev blocks n =
assert_norm (words_state SHA2_224 == words_state SHA2_256);
let h0 = ST.get () in
Spec.SHA2.Lemmas.update_multi_224_256 (B.as_seq h0 s) (B.as_seq h0 blocks);
update_multi_256 s ev blocks n
#push-options "--ifuel 1"
let update_multi #a s prevlen blocks len =
match !*s with
| MD5_s p ->
let n = len / block_len MD5 in
Hacl.Hash.MD5.legacy_update_multi p () blocks n
| SHA1_s p ->
let n = len / block_len SHA1 in
Hacl.Hash.SHA1.legacy_update_multi p () blocks n
| SHA2_224_s p ->
let n = len / block_len SHA2_224 in
update_multi_224 p () blocks n
| SHA2_256_s p ->
let n = len / block_len SHA2_256 in
update_multi_256 p () blocks n
| SHA2_384_s p ->
let n = len / block_len SHA2_384 in
Hacl.Hash.SHA2.update_multi_384 p () blocks n
| SHA2_512_s p ->
let n = len / block_len SHA2_512 in
Hacl.Hash.SHA2.update_multi_512 p () blocks n
| SHA3_224_s p -> let n = len / block_len SHA3_224 in Hacl.Hash.SHA3.update_multi SHA3_224 p () blocks n
| SHA3_256_s p -> let n = len / block_len SHA3_256 in Hacl.Hash.SHA3.update_multi SHA3_256 p () blocks n
| SHA3_384_s p -> let n = len / block_len SHA3_384 in Hacl.Hash.SHA3.update_multi SHA3_384 p () blocks n
| SHA3_512_s p -> let n = len / block_len SHA3_512 in Hacl.Hash.SHA3.update_multi SHA3_512 p () blocks n
| Blake2S_s p ->
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_32 p prevlen blocks n in
()
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
let n = len / block_len Blake2S in
let _ = Hacl.Hash.Blake2.update_multi_blake2s_128 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
| Blake2B_s p ->
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_32 p prevlen blocks n in
()
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
[@inline_let] let prevlen = Int.Cast.Full.uint64_to_uint128 prevlen in
let n = len / block_len Blake2B in
let _ = Hacl.Hash.Blake2.update_multi_blake2b_256 p prevlen blocks n in
()
else LowStar.Ignore.ignore p
#pop-options
let update_last #a s prev_len last last_len =
[@inline_let] let cast = FStar.Int.Cast.Full.uint64_to_uint128 in
match !*s with
| MD5_s p ->
Hacl.Hash.MD5.legacy_update_last p prev_len last last_len
| SHA1_s p ->
Hacl.Hash.SHA1.legacy_update_last p prev_len last last_len
| SHA2_224_s p ->
Hacl.Hash.SHA2.update_last_224 p prev_len last last_len
| SHA2_256_s p ->
Hacl.Hash.SHA2.update_last_256 p prev_len last last_len
| SHA2_384_s p ->
Hacl.Hash.SHA2.update_last_384 p (cast prev_len) last last_len
| SHA2_512_s p ->
Hacl.Hash.SHA2.update_last_512 p (cast prev_len) last last_len
| SHA3_224_s p -> Hacl.Hash.SHA3.update_last SHA3_224 p () last last_len
| SHA3_256_s p -> Hacl.Hash.SHA3.update_last SHA3_256 p () last last_len
| SHA3_384_s p -> Hacl.Hash.SHA3.update_last SHA3_384 p () last last_len
| SHA3_512_s p -> Hacl.Hash.SHA3.update_last SHA3_512 p () last last_len
| Blake2S_s p ->
Hacl.Hash.Blake2.update_last_blake2s_32 p prev_len last last_len
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.update_last_blake2s_128 p prev_len last last_len
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.update_last_blake2b_32 p (cast prev_len) last last_len
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.update_last_blake2b_256 p (cast prev_len) last last_len
else LowStar.Ignore.ignore p
// TODO: move to FStar.Math.Lemmas
val modulo_sub_lemma (a : int) (b : nat) (c : pos) :
Lemma
(requires (b < c /\ (a - b) % c = 0))
(ensures (b = a % c))
let modulo_sub_lemma a b c =
calc(==) {
(a - b) % c;
(==) { Math.Lemmas.lemma_mod_add_distr (-b) a c }
((a % c) - b) % c;
};
assert(- c < (a % c) - b);
assert((a % c) - b < c);
Math.Lemmas.euclidean_division_definition ((a % c) - b) c;
assert(a % c - b = ((a % c - b) / c) * c);
assert(1 * c = c);
assert((-1) * c = - c);
let d = (a % c - b) / c in
if 1 <= d then
begin
Math.Lemmas.lemma_mult_le_right c 1 d;
assert(d * c >= 1 * c);
assert(False)
end;
if d <= -1 then
begin
Math.Lemmas.lemma_mult_le_right c d (-1);
assert(d * c <= (-1) * c);
assert(d * c <= - c);
assert(False)
end;
assert(d = 0);
assert(d * c = 0);
assert(a % c - b = 0);
assert(a % c = b)
#push-options "--ifuel 1"
let finish #a s dst =
match !*s with
| MD5_s p -> Hacl.Hash.MD5.legacy_finish p dst
| SHA1_s p -> Hacl.Hash.SHA1.legacy_finish p dst
| SHA2_224_s p -> Hacl.Hash.SHA2.finish_224 p dst
| SHA2_256_s p -> Hacl.Hash.SHA2.finish_256 p dst
| SHA2_384_s p -> Hacl.Hash.SHA2.finish_384 p dst
| SHA2_512_s p -> Hacl.Hash.SHA2.finish_512 p dst
| SHA3_224_s p -> Hacl.Hash.SHA3.finish SHA3_224 p dst
| SHA3_256_s p -> Hacl.Hash.SHA3.finish SHA3_256 p dst
| SHA3_384_s p -> Hacl.Hash.SHA3.finish SHA3_384 p dst
| SHA3_512_s p -> Hacl.Hash.SHA3.finish SHA3_512 p dst
| Blake2S_s p -> Hacl.Hash.Blake2.finish_blake2s_32 p dst
| Blake2S_128_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec128 then
Hacl.Hash.Blake2.finish_blake2s_128 p dst
else LowStar.Ignore.ignore p
| Blake2B_s p ->
Hacl.Hash.Blake2.finish_blake2b_32 p dst
| Blake2B_256_s _ p ->
if EverCrypt.TargetConfig.hacl_can_compile_vec256 then
Hacl.Hash.Blake2.finish_blake2b_256 p dst
else LowStar.Ignore.ignore p
#pop-options
let free_ #ea s =
begin match !*s with
| MD5_s p -> B.free p
| SHA1_s p -> B.free p
| SHA2_224_s p -> B.free p
| SHA2_256_s p -> B.free p
| SHA2_384_s p -> B.free p
| SHA2_512_s p -> B.free p
| SHA3_224_s p -> B.free p
| SHA3_256_s p -> B.free p
| SHA3_384_s p -> B.free p
| SHA3_512_s p -> B.free p
| Blake2S_s p -> B.free p
| Blake2S_128_s _ p -> B.free p
| Blake2B_s p -> B.free p
| Blake2B_256_s _ p -> B.free p
end;
B.free s
#push-options "--ifuel 1" | false | false | EverCrypt.Hash.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val copy:
#a:e_alg -> (
let a = Ghost.reveal a in
s_src:state a ->
s_dst:state a ->
Stack unit
(requires (fun h0 ->
invariant s_src h0 /\
invariant s_dst h0 /\
B.(loc_disjoint (footprint s_src h0) (footprint s_dst h0))))
(ensures fun h0 _ h1 ->
M.(modifies (footprint s_dst h0) h0 h1) /\
footprint s_dst h0 == footprint s_dst h1 /\
preserves_freeable s_dst h0 h1 /\
invariant s_dst h1 /\
repr s_dst h1 == repr s_src h0)) | [] | EverCrypt.Hash.copy | {
"file_name": "providers/evercrypt/fst/EverCrypt.Hash.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | let a = FStar.Ghost.reveal a in
s_src: EverCrypt.Hash.state a -> s_dst: EverCrypt.Hash.state a
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 9,
"end_line": 642,
"start_col": 2,
"start_line": 544
} |
Prims.Tot | val openBase: openBase_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.DH",
"short_module": "IDH"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.HPKE",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let openBase = hpke_openBase_higher #cs vale_p IAEAD.aead_decrypt_cp32 setupBaseR | val openBase: openBase_st cs vale_p
let openBase = | false | null | false | hpke_openBase_higher #cs vale_p IAEAD.aead_decrypt_cp32 setupBaseR | {
"checked_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.HPKE.Interface.AEAD.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst"
} | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_openBase_higher",
"Hacl.HPKE.Curve64_CP32_SHA256.cs",
"Hacl.HPKE.Curve64_CP32_SHA256.vale_p",
"Hacl.HPKE.Interface.AEAD.aead_decrypt_cp32",
"Hacl.HPKE.Curve64_CP32_SHA256.setupBaseR"
] | [] | module Hacl.HPKE.Curve64_CP32_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0"
let setupBaseS = hpke_setupBaseS_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256
let setupBaseR = hpke_setupBaseR_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64
let sealBase = hpke_sealBase_higher #cs vale_p IAEAD.aead_encrypt_cp32 setupBaseS | false | true | Hacl.HPKE.Curve64_CP32_SHA256.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val openBase: openBase_st cs vale_p | [] | Hacl.HPKE.Curve64_CP32_SHA256.openBase | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP32_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.openBase_st Hacl.HPKE.Curve64_CP32_SHA256.cs Hacl.HPKE.Curve64_CP32_SHA256.vale_p | {
"end_col": 81,
"end_line": 20,
"start_col": 15,
"start_line": 20
} |
Prims.Tot | val sealBase: sealBase_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.DH",
"short_module": "IDH"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.HPKE",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sealBase = hpke_sealBase_higher #cs vale_p IAEAD.aead_encrypt_cp32 setupBaseS | val sealBase: sealBase_st cs vale_p
let sealBase = | false | null | false | hpke_sealBase_higher #cs vale_p IAEAD.aead_encrypt_cp32 setupBaseS | {
"checked_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.HPKE.Interface.AEAD.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst"
} | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_sealBase_higher",
"Hacl.HPKE.Curve64_CP32_SHA256.cs",
"Hacl.HPKE.Curve64_CP32_SHA256.vale_p",
"Hacl.HPKE.Interface.AEAD.aead_encrypt_cp32",
"Hacl.HPKE.Curve64_CP32_SHA256.setupBaseS"
] | [] | module Hacl.HPKE.Curve64_CP32_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0"
let setupBaseS = hpke_setupBaseS_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256
let setupBaseR = hpke_setupBaseR_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 | false | true | Hacl.HPKE.Curve64_CP32_SHA256.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sealBase: sealBase_st cs vale_p | [] | Hacl.HPKE.Curve64_CP32_SHA256.sealBase | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP32_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.sealBase_st Hacl.HPKE.Curve64_CP32_SHA256.cs Hacl.HPKE.Curve64_CP32_SHA256.vale_p | {
"end_col": 81,
"end_line": 18,
"start_col": 15,
"start_line": 18
} |
Prims.Tot | val setupBaseS: setupBaseS_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.DH",
"short_module": "IDH"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.HPKE",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let setupBaseS = hpke_setupBaseS_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 | val setupBaseS: setupBaseS_st cs vale_p
let setupBaseS = | false | null | false | hpke_setupBaseS_higher #cs
vale_p
IHK.hkdf_expand256
IHK.hkdf_extract256
IDH.secret_to_public_c64
IDH.dh_c64
IHK.hkdf_expand256
IHK.hkdf_extract256 | {
"checked_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.HPKE.Interface.AEAD.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst"
} | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_setupBaseS_higher",
"Hacl.HPKE.Curve64_CP32_SHA256.cs",
"Hacl.HPKE.Curve64_CP32_SHA256.vale_p",
"Hacl.HPKE.Interface.HKDF.hkdf_expand256",
"Hacl.HPKE.Interface.HKDF.hkdf_extract256",
"Hacl.HPKE.Interface.DH.secret_to_public_c64",
"Hacl.HPKE.Interface.DH.dh_c64"
] | [] | module Hacl.HPKE.Curve64_CP32_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0" | false | true | Hacl.HPKE.Curve64_CP32_SHA256.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val setupBaseS: setupBaseS_st cs vale_p | [] | Hacl.HPKE.Curve64_CP32_SHA256.setupBaseS | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP32_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.setupBaseS_st Hacl.HPKE.Curve64_CP32_SHA256.cs Hacl.HPKE.Curve64_CP32_SHA256.vale_p | {
"end_col": 164,
"end_line": 14,
"start_col": 17,
"start_line": 14
} |
Prims.Tot | val setupBaseR: setupBaseR_st cs vale_p | [
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.AEAD",
"short_module": "IAEAD"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.Hash",
"short_module": "IHash"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.HKDF",
"short_module": "IHK"
},
{
"abbrev": true,
"full_module": "Hacl.HPKE.Interface.DH",
"short_module": "IDH"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.HPKE",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let setupBaseR = hpke_setupBaseR_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 | val setupBaseR: setupBaseR_st cs vale_p
let setupBaseR = | false | null | false | hpke_setupBaseR_higher #cs
vale_p
IHK.hkdf_expand256
IHK.hkdf_extract256
IDH.dh_c64
IHK.hkdf_expand256
IHK.hkdf_extract256
IDH.secret_to_public_c64 | {
"checked_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.Meta.HPKE.fst.checked",
"Hacl.HPKE.Interface.HKDF.fst.checked",
"Hacl.HPKE.Interface.Hash.fst.checked",
"Hacl.HPKE.Interface.DH.fst.checked",
"Hacl.HPKE.Interface.AEAD.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.HPKE.Curve64_CP32_SHA256.fst"
} | [
"total"
] | [
"Hacl.Meta.HPKE.hpke_setupBaseR_higher",
"Hacl.HPKE.Curve64_CP32_SHA256.cs",
"Hacl.HPKE.Curve64_CP32_SHA256.vale_p",
"Hacl.HPKE.Interface.HKDF.hkdf_expand256",
"Hacl.HPKE.Interface.HKDF.hkdf_extract256",
"Hacl.HPKE.Interface.DH.dh_c64",
"Hacl.HPKE.Interface.DH.secret_to_public_c64"
] | [] | module Hacl.HPKE.Curve64_CP32_SHA256
open Hacl.Meta.HPKE
module IDH = Hacl.HPKE.Interface.DH
module IHK = Hacl.HPKE.Interface.HKDF
module IHash = Hacl.HPKE.Interface.Hash
module IAEAD = Hacl.HPKE.Interface.AEAD
friend Hacl.Meta.HPKE
#set-options "--fuel 0 --ifuel 0"
let setupBaseS = hpke_setupBaseS_higher #cs vale_p IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_c64 IDH.dh_c64 IHK.hkdf_expand256 IHK.hkdf_extract256 | false | true | Hacl.HPKE.Curve64_CP32_SHA256.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val setupBaseR: setupBaseR_st cs vale_p | [] | Hacl.HPKE.Curve64_CP32_SHA256.setupBaseR | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP32_SHA256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.HPKE.setupBaseR_st Hacl.HPKE.Curve64_CP32_SHA256.cs Hacl.HPKE.Curve64_CP32_SHA256.vale_p | {
"end_col": 164,
"end_line": 16,
"start_col": 17,
"start_line": 16
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c)) | let bn_almost_mont_reduction_st (t: limb_t) (len: size_t{0 < v len /\ v len + v len <= max_size_t}) = | false | null | false | n: lbignum t len -> mu: limb t -> c: lbignum t (len +! len) -> res: lbignum t len
-> Stack unit
(requires
fun h ->
live h n /\ live h c /\ live h res /\ disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures
fun h0 _ h1 ->
modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c)) | {
"checked_file": "Hacl.Bignum.AlmostMontgomery.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.AlmostMontgomery.fsti"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Lib.IntTypes.op_Plus_Bang",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.AlmostMontgomery.bn_almost_mont_reduction"
] | [] | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Almost Montgomery Multiplication
inline_for_extraction noextract | false | false | Hacl.Bignum.AlmostMontgomery.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_almost_mont_reduction_st : t: Hacl.Bignum.Definitions.limb_t ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t }
-> Type0 | [] | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_reduction_st | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Bignum.Definitions.limb_t ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t }
-> Type0 | {
"end_col": 79,
"end_line": 32,
"start_col": 4,
"start_line": 23
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_almost_mont_sqr_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_sqr (as_seq h0 n) mu (as_seq h0 aM)) | let bn_almost_mont_sqr_st (t: limb_t) (len: BN.meta_len t) = | false | null | false | n: lbignum t len -> mu: limb t -> aM: lbignum t len -> resM: lbignum t len
-> Stack unit
(requires
fun h -> live h aM /\ live h resM /\ live h n /\ disjoint resM n /\ eq_or_disjoint aM resM)
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_sqr (as_seq h0 n) mu (as_seq h0 aM)) | {
"checked_file": "Hacl.Bignum.AlmostMontgomery.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.AlmostMontgomery.fsti"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.AlmostMontgomery.bn_almost_mont_sqr"
] | [] | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Almost Montgomery Multiplication
inline_for_extraction noextract
let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c))
inline_for_extraction noextract
val bn_almost_mont_reduction: #t:limb_t -> k:BN.bn t -> bn_almost_mont_reduction_st t k.BN.len
inline_for_extraction noextract
let bn_almost_mont_mul_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> bM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM bM /\
eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_mul (as_seq h0 n) mu (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_almost_mont_mul:
#t:limb_t
-> k:BN.bn t
-> mr:bn_almost_mont_reduction_st t k.BN.len ->
bn_almost_mont_mul_st t k.BN.len
inline_for_extraction noextract | false | false | Hacl.Bignum.AlmostMontgomery.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_almost_mont_sqr_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | [] | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_sqr_st | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | {
"end_col": 75,
"end_line": 74,
"start_col": 4,
"start_line": 65
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_almost_mont_mul_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> bM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM bM /\
eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_mul (as_seq h0 n) mu (as_seq h0 aM) (as_seq h0 bM)) | let bn_almost_mont_mul_st (t: limb_t) (len: BN.meta_len t) = | false | null | false | n: lbignum t len -> mu: limb t -> aM: lbignum t len -> bM: lbignum t len -> resM: lbignum t len
-> Stack unit
(requires
fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\ disjoint resM n /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_mul (as_seq h0 n) mu (as_seq h0 aM) (as_seq h0 bM)) | {
"checked_file": "Hacl.Bignum.AlmostMontgomery.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.AlmostMontgomery.fsti"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.AlmostMontgomery.bn_almost_mont_mul"
] | [] | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Almost Montgomery Multiplication
inline_for_extraction noextract
let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c))
inline_for_extraction noextract
val bn_almost_mont_reduction: #t:limb_t -> k:BN.bn t -> bn_almost_mont_reduction_st t k.BN.len
inline_for_extraction noextract | false | false | Hacl.Bignum.AlmostMontgomery.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_almost_mont_mul_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | [] | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_mul_st | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | {
"end_col": 90,
"end_line": 52,
"start_col": 4,
"start_line": 41
} |
|
Prims.Tot | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64 | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64}
let crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} = | false | null | false | crypto_bytes FP.Frodo64 | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.Frodo64"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ] | false | false | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} | [] | Hacl.Frodo64.crypto_bytes | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_bytes Spec.Frodo.Params.Frodo64} | {
"end_col": 25,
"end_line": 23,
"start_col": 2,
"start_line": 23
} |
Prims.Tot | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_kem_dec ss ct sk =
crypto_kem_dec FP.Frodo64 FP.SHAKE128 ss ct sk | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128
let crypto_kem_dec ss ct sk = | false | null | false | crypto_kem_dec FP.Frodo64 FP.SHAKE128 ss ct sk | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Frodo.KEM.crypto_kem_dec",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64)
let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64)
val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128
let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk
val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128
let crypto_kem_enc ct ss pk =
crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk
val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | false | true | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | [] | Hacl.Frodo64.crypto_kem_dec | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Frodo.KEM.crypto_kem_dec_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | {
"end_col": 48,
"end_line": 45,
"start_col": 2,
"start_line": 45
} |
Prims.Tot | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_kem_enc ct ss pk =
crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128
let crypto_kem_enc ct ss pk = | false | null | false | crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Hacl.Frodo.KEM.crypto_kem_enc",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64)
let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64)
val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128
let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk
val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | false | true | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | [] | Hacl.Frodo64.crypto_kem_enc | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Frodo.KEM.crypto_kem_enc_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | {
"end_col": 48,
"end_line": 41,
"start_col": 2,
"start_line": 41
} |
Prims.Tot | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128
let crypto_kem_keypair pk sk = | false | null | false | crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Frodo.KEM.crypto_kem_keypair",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64)
let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64)
val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | false | true | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | [] | Hacl.Frodo64.crypto_kem_keypair | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Frodo.KEM.crypto_kem_keypair_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | {
"end_col": 49,
"end_line": 37,
"start_col": 2,
"start_line": 37
} |
Prims.Tot | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64) | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64}
let crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} = | false | null | false | normalize_term (crypto_publickeybytes FP.Frodo64) | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Spec.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64 | false | false | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} | [] | Hacl.Frodo64.crypto_publickeybytes | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_publickeybytes Spec.Frodo.Params.Frodo64} | {
"end_col": 51,
"end_line": 26,
"start_col": 2,
"start_line": 26
} |
Prims.Tot | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64) | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64}
let crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} = | false | null | false | normalize_term (crypto_ciphertextbytes FP.Frodo64) | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64) | false | false | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} | [] | Hacl.Frodo64.crypto_ciphertextbytes | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_ciphertextbytes Spec.Frodo.Params.Frodo64} | {
"end_col": 52,
"end_line": 32,
"start_col": 2,
"start_line": 32
} |
Prims.Tot | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64) | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64}
let crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} = | false | null | false | normalize_term (crypto_secretkeybytes FP.Frodo64) | {
"checked_file": "Hacl.Frodo64.fst.checked",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
"total"
] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes"
] | [] | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64) | false | false | Hacl.Frodo64.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} | [] | Hacl.Frodo64.crypto_secretkeybytes | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_secretkeybytes Spec.Frodo.Params.Frodo64} | {
"end_col": 51,
"end_line": 29,
"start_col": 2,
"start_line": 29
} |
Prims.GTot | val i_sel (#r: rid) (#a: Type) (#p: (seq a -> Type)) (h: mem) (m: i_seq r a p)
: GTot (s: seq a {p s}) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m | val i_sel (#r: rid) (#a: Type) (#p: (seq a -> Type)) (h: mem) (m: i_seq r a p)
: GTot (s: seq a {p s})
let i_sel (#r: rid) (#a: Type) (#p: (seq a -> Type)) (h: mem) (m: i_seq r a p)
: GTot (s: seq a {p s}) = | false | null | false | HS.sel h m | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.grows_p"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_sel (#r: rid) (#a: Type) (#p: (seq a -> Type)) (h: mem) (m: i_seq r a p)
: GTot (s: seq a {p s}) | [] | FStar.Monotonic.Seq.i_sel | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | h: FStar.Monotonic.HyperStack.mem -> m: FStar.Monotonic.Seq.i_seq r a p
-> Prims.GTot (s: FStar.Seq.Base.seq a {p s}) | {
"end_col": 14,
"end_line": 132,
"start_col": 4,
"start_line": 132
} |
Prims.Tot | val int_at_most (#r #a #p: _) (x: int) (is: i_seq r a p) (h: mem) : Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is) | val int_at_most (#r #a #p: _) (x: int) (is: i_seq r a p) (h: mem) : Type0
let int_at_most #r #a #p (x: int) (is: i_seq r a p) (h: mem) : Type0 = | false | null | false | x < Seq.length (HS.sel h is) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.int",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.mem",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.grows_p"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val int_at_most (#r #a #p: _) (x: int) (is: i_seq r a p) (h: mem) : Type0 | [] | FStar.Monotonic.Seq.int_at_most | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: Prims.int -> is: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem -> Type0 | {
"end_col": 30,
"end_line": 124,
"start_col": 2,
"start_line": 124
} |
Prims.GTot | val i_contains (#r: rid) (#a: Type) (#p: (seq a -> Type)) (m: i_seq r a p) (h: mem) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m | val i_contains (#r: rid) (#a: Type) (#p: (seq a -> Type)) (m: i_seq r a p) (h: mem) : GTot Type0
let i_contains (#r: rid) (#a: Type) (#p: (seq a -> Type)) (m: i_seq r a p) (h: mem) : GTot Type0 = | false | null | false | HS.contains h m | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.HyperStack.contains",
"FStar.Monotonic.Seq.grows_p"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_contains (#r: rid) (#a: Type) (#p: (seq a -> Type)) (m: i_seq r a p) (h: mem) : GTot Type0 | [] | FStar.Monotonic.Seq.i_contains | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem -> Prims.GTot Type0 | {
"end_col": 19,
"end_line": 142,
"start_col": 4,
"start_line": 142
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r)) | let collect_prefix
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
(h: mem)
= | false | null | false | grows bs (collect f (HS.sel h r)) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.collect",
"FStar.Monotonic.HyperStack.sel"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_prefix : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | [] | FStar.Monotonic.Seq.collect_prefix | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | {
"end_col": 35,
"end_line": 332,
"start_col": 2,
"start_line": 332
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let grows #a = grows_aux #a | let grows #a = | false | null | false | grows_aux #a | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.grows_aux",
"FStar.Preorder.preorder",
"FStar.Seq.Base.seq"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val grows : FStar.Preorder.preorder (FStar.Seq.Base.seq a) | [] | FStar.Monotonic.Seq.grows | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Preorder.preorder (FStar.Seq.Base.seq a) | {
"end_col": 27,
"end_line": 47,
"start_col": 15,
"start_line": 47
} |
|
Prims.Tot | val snoc (s: seq 'a) (x: 'a) : Tot (seq 'a) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x) | val snoc (s: seq 'a) (x: 'a) : Tot (seq 'a)
let snoc (s: seq 'a) (x: 'a) : Tot (seq 'a) = | false | null | false | Seq.append s (Seq.create 1 x) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val snoc (s: seq 'a) (x: 'a) : Tot (seq 'a) | [] | FStar.Monotonic.Seq.snoc | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.Seq.Base.seq 'a -> x: 'a -> FStar.Seq.Base.seq 'a | {
"end_col": 33,
"end_line": 53,
"start_col": 4,
"start_line": 53
} |
Prims.GTot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v | let collect_has_at_index
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
(h: mem)
= | false | null | false | let s = HS.sel h r in
n < Seq.length (collect f s) /\ Seq.index (collect f s) n == v | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.Seq.collect",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Monotonic.HyperStack.sel",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_has_at_index : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | [] | FStar.Monotonic.Seq.collect_has_at_index | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | {
"end_col": 35,
"end_line": 353,
"start_col": 27,
"start_line": 350
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_At s1 s2 = Seq.append s1 s2 | let op_At s1 s2 = | false | null | false | Seq.append s1 s2 | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_At : s1: FStar.Seq.Base.seq _ -> s2: FStar.Seq.Base.seq _ -> FStar.Seq.Base.seq _ | [] | FStar.Monotonic.Seq.op_At | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.Seq.Base.seq _ -> s2: FStar.Seq.Base.seq _ -> FStar.Seq.Base.seq _ | {
"end_col": 42,
"end_line": 210,
"start_col": 26,
"start_line": 210
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p) | let i_seq (r: rid) (a: Type) (p: (seq a -> Type)) = | false | null | false | m_rref r (s: seq a {p s}) (grows_p p) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.HyperStack.ST.m_rref",
"FStar.Monotonic.Seq.grows_p"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2 | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_seq : r: FStar.Monotonic.Seq.rid -> a: Type0 -> p: (_: FStar.Seq.Base.seq a -> Type) -> Type0 | [] | FStar.Monotonic.Seq.i_seq | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | r: FStar.Monotonic.Seq.rid -> a: Type0 -> p: (_: FStar.Seq.Base.seq a -> Type) -> Type0 | {
"end_col": 82,
"end_line": 107,
"start_col": 47,
"start_line": 107
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let increases (x:int) (y:int) = b2t (x <= y) | let increases (x y: int) = | false | null | false | b2t (x <= y) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"Prims.int",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows | false | true | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val increases : x: Prims.int -> y: Prims.int -> Prims.logical | [] | FStar.Monotonic.Seq.increases | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: Prims.int -> y: Prims.int -> Prims.logical | {
"end_col": 44,
"end_line": 368,
"start_col": 32,
"start_line": 368
} |
|
Prims.GTot | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log) | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0
let at_most_log_len (#l: rid) (#a: Type) (x: nat) (log: log_t l a) : mem -> GTot Type0 = | false | null | false | fun h -> x <= Seq.length (HS.sel h log) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.HyperStack.mem",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0 | [] | FStar.Monotonic.Seq.at_most_log_len | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a -> _: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | {
"end_col": 45,
"end_line": 372,
"start_col": 6,
"start_line": 372
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r)) | let map_prefix
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
(h: mem)
= | false | null | false | grows bs (map f (HS.sel h r)) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.map",
"FStar.Monotonic.HyperStack.sel"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_prefix : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | [] | FStar.Monotonic.Seq.map_prefix | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | {
"end_col": 31,
"end_line": 269,
"start_col": 2,
"start_line": 269
} |
|
FStar.Pervasives.Lemma | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a) | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
let at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) = | false | null | true | reveal_opaque (`%grows) (grows #a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.at_least",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) | [] | FStar.Monotonic.Seq.at_least_is_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
n: Prims.nat ->
x: a ->
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.at_least n x r)) | {
"end_col": 38,
"end_line": 79,
"start_col": 4,
"start_line": 79
} |
FStar.Pervasives.Lemma | val lemma_snoc_extends (#a: Type) (s: seq a) (x: a)
: Lemma (requires True) (ensures (grows s (Seq.snoc s x))) [SMTPat (grows s (Seq.snoc s x))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a) | val lemma_snoc_extends (#a: Type) (s: seq a) (x: a)
: Lemma (requires True) (ensures (grows s (Seq.snoc s x))) [SMTPat (grows s (Seq.snoc s x))]
let lemma_snoc_extends (#a: Type) (s: seq a) (x: a)
: Lemma (requires True) (ensures (grows s (Seq.snoc s x))) [SMTPat (grows s (Seq.snoc s x))] = | false | null | true | reveal_opaque (`%grows) (grows #a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Seq.Properties.snoc",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x))) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_snoc_extends (#a: Type) (s: seq a) (x: a)
: Lemma (requires True) (ensures (grows s (Seq.snoc s x))) [SMTPat (grows s (Seq.snoc s x))] | [] | FStar.Monotonic.Seq.lemma_snoc_extends | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma (ensures FStar.Monotonic.Seq.grows s (FStar.Seq.Properties.snoc s x))
[SMTPat (FStar.Monotonic.Seq.grows s (FStar.Seq.Properties.snoc s x))] | {
"end_col": 38,
"end_line": 59,
"start_col": 4,
"start_line": 59
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x | let at_least (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows) (h: mem) = | false | null | false | Seq.length (HS.sel h r) > n /\ Seq.index (HS.sel h r) n == x | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val at_least : n: Prims.nat ->
x: a ->
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | [] | FStar.Monotonic.Seq.at_least | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
n: Prims.nat ->
x: a ->
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | {
"end_col": 34,
"end_line": 75,
"start_col": 4,
"start_line": 74
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x | let i_at_least (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p) (h: mem) = | false | null | false | Seq.length (HS.sel h m) > n /\ Seq.index (HS.sel h m) n == x | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.grows_p",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_at_least : n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | [] | FStar.Monotonic.Seq.i_at_least | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | {
"end_col": 38,
"end_line": 117,
"start_col": 8,
"start_line": 116
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j | let invariant (s: seq nat) = | false | null | false | forall (i: nat) (j: nat).
i < Seq.length s /\ j < Seq.length s /\ i <> j ==> Seq.index s i <> Seq.index s j | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_disEquality",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
//////////////////////////////////////////////////////////////////////////////// | false | true | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val invariant : s: FStar.Seq.Base.seq Prims.nat -> Prims.logical | [] | FStar.Monotonic.Seq.invariant | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.Seq.Base.seq Prims.nat -> Prims.logical | {
"end_col": 37,
"end_line": 167,
"start_col": 2,
"start_line": 166
} |
|
Prims.Tot | val grows_aux (#a: Type) : Preorder.preorder (seq a) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i) | val grows_aux (#a: Type) : Preorder.preorder (seq a)
let grows_aux (#a: Type) : Preorder.preorder (seq a) = | false | null | false | fun (s1: seq a) (s2: seq a) ->
length s1 <= length s2 /\
(forall (i: nat). {:pattern (Seq.index s1 i)\/(Seq.index s2 i)}
i < length s1 ==> index s1 i == index s2 i) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.logical",
"FStar.Preorder.preorder"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val grows_aux (#a: Type) : Preorder.preorder (seq a) | [] | FStar.Monotonic.Seq.grows_aux | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Preorder.preorder (FStar.Seq.Base.seq a) | {
"end_col": 111,
"end_line": 44,
"start_col": 4,
"start_line": 42
} |
FStar.HyperStack.ST.ST | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1))
let alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) = | true | null | false | ralloc r init | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mref",
"FStar.HyperStack.ST.m_rref",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel",
"FStar.HyperStack.ST.ralloc_post"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\ | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) | [] | FStar.Monotonic.Seq.alloc_mref_seq | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | r: FStar.Monotonic.Seq.rid -> init: FStar.Seq.Base.seq a
-> FStar.HyperStack.ST.ST
(FStar.HyperStack.ST.m_rref r (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows) | {
"end_col": 17,
"end_line": 68,
"start_col": 4,
"start_line": 68
} |
Prims.Tot | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s = | false | null | false | let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.index",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
//////////////////////////////////////////////////////////////////////////////// | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a) | [] | FStar.Monotonic.Seq.un_snoc | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> FStar.Seq.Base.seq a * a | {
"end_col": 38,
"end_line": 195,
"start_col": 18,
"start_line": 193
} |
Prims.Tot | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2 | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s})
let grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) = | false | null | false | fun s1 s2 -> grows s1 s2 | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Preorder.preorder"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
//////////////////////////////////////////////////////////////////////////////// | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) | [] | FStar.Monotonic.Seq.grows_p | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: (_: FStar.Seq.Base.seq a -> Type) -> FStar.Preorder.preorder (s: FStar.Seq.Base.seq a {p s}) | {
"end_col": 26,
"end_line": 105,
"start_col": 2,
"start_line": 105
} |
FStar.Pervasives.Lemma | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3))
let map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) = | false | null | true | reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"FStar.Monotonic.Seq.map",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3 | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) | [] | FStar.Monotonic.Seq.map_grows | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> b) -> s1: FStar.Seq.Base.seq a -> s3: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.grows s1 s3 ==>
FStar.Monotonic.Seq.grows (FStar.Monotonic.Seq.map f s1) (FStar.Monotonic.Seq.map f s3)) | {
"end_col": 38,
"end_line": 262,
"start_col": 4,
"start_line": 261
} |
FStar.Pervasives.Lemma | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a = | false | null | true | let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Seq.Properties.snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | [] | FStar.Monotonic.Seq.collect_snoc | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s: FStar.Seq.Base.seq 'a -> a: 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.collect f (FStar.Seq.Properties.snoc s a) ==
FStar.Seq.Base.append (FStar.Monotonic.Seq.collect f s) (f a)) | {
"end_col": 26,
"end_line": 308,
"start_col": 24,
"start_line": 306
} |
FStar.Pervasives.Lemma | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs))
let map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) = | false | null | true | reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.map_prefix",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) | [] | FStar.Monotonic.Seq.map_prefix_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.map_prefix r f bs)) | {
"end_col": 38,
"end_line": 275,
"start_col": 4,
"start_line": 274
} |
FStar.Pervasives.Lemma | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a) | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is))
let int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) = | false | null | true | reveal_opaque (`%grows) (grows #a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.i_seq",
"Prims.int",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.int_at_most",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) | [] | FStar.Monotonic.Seq.int_at_most_is_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | is: FStar.Monotonic.Seq.i_seq r a p -> k: Prims.int
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t is (FStar.Monotonic.Seq.int_at_most k is)) | {
"end_col": 38,
"end_line": 128,
"start_col": 4,
"start_line": 128
} |
FStar.HyperStack.ST.ST | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a) | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k = | true | null | false | let h0 = HST.get () in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k)
in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.at_least",
"FStar.Seq.Base.index",
"FStar.Monotonic.HyperStack.sel",
"Prims.unit",
"FStar.Seq.Properties.contains_intro",
"FStar.Monotonic.Seq.at_least_is_stable",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a))) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True)) | [] | FStar.Monotonic.Seq.test0 | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.Monotonic.Seq.rid ->
a: FStar.HyperStack.ST.m_rref r (FStar.Seq.Base.seq Prims.nat) FStar.Monotonic.Seq.grows ->
k: Prims.nat
-> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 57,
"end_line": 178,
"start_col": 17,
"start_line": 172
} |
Prims.GTot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v | let map_has_at_index
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
(h: mem)
= | false | null | false | let s = HS.sel h r in
n < Seq.length s /\ Seq.index (map f s) n == v | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Monotonic.Seq.map",
"FStar.Monotonic.HyperStack.sel",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_has_at_index : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | [] | FStar.Monotonic.Seq.map_has_at_index | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | {
"end_col": 31,
"end_line": 283,
"start_col": 30,
"start_line": 280
} |
|
FStar.HyperStack.ST.ST | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m))
let i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) = | true | null | false | !m | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"FStar.HyperStack.ST.op_Bang",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.l_or",
"Prims.squash",
"FStar.Monotonic.Seq.i_sel"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True)) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) | [] | FStar.Monotonic.Seq.i_read | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | m: FStar.Monotonic.Seq.i_seq r a p -> FStar.HyperStack.ST.ST (s: FStar.Seq.Base.seq a {p s}) | {
"end_col": 6,
"end_line": 138,
"start_col": 4,
"start_line": 138
} |
Prims.Tot | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last) | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s = | false | null | false | if Seq.length s = 0
then Seq.empty
else
let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Monotonic.Seq.collect",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | [
"recursion"
] | FStar.Monotonic.Seq.collect | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s: FStar.Seq.Base.seq 'a -> Prims.Tot (FStar.Seq.Base.seq 'b) | {
"end_col": 45,
"end_line": 302,
"start_col": 2,
"start_line": 300
} |
FStar.HyperStack.ST.ST | val alloc_mref_iseq (#a: Type) (p: (seq a -> Type)) (r: rid) (init: seq a {p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init | val alloc_mref_iseq (#a: Type) (p: (seq a -> Type)) (r: rid) (init: seq a {p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
let alloc_mref_iseq (#a: Type) (p: (seq a -> Type)) (r: rid) (init: seq a {p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1)) = | true | null | false | ralloc r init | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.grows_p",
"FStar.HyperStack.ST.mref",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"FStar.HyperStack.ST.ralloc_post"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r))) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alloc_mref_iseq (#a: Type) (p: (seq a -> Type)) (r: rid) (init: seq a {p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1)) | [] | FStar.Monotonic.Seq.alloc_mref_iseq | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
p: (_: FStar.Seq.Base.seq a -> Type) ->
r: FStar.Monotonic.Seq.rid ->
init: FStar.Seq.Base.seq a {p init}
-> FStar.HyperStack.ST.ST (FStar.Monotonic.Seq.i_seq r a p) | {
"end_col": 17,
"end_line": 113,
"start_col": 4,
"start_line": 113
} |
FStar.Pervasives.Lemma | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a = | false | null | true | let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Seq.Properties.snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a)) | [] | FStar.Monotonic.Seq.map_snoc | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> a: 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.map f (FStar.Seq.Properties.snoc s a) ==
FStar.Seq.Properties.snoc (FStar.Monotonic.Seq.map f s) (f a)) | {
"end_col": 26,
"end_line": 208,
"start_col": 20,
"start_line": 206
} |
FStar.Pervasives.Lemma | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a) | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
let map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) = | false | null | true | reveal_opaque (`%grows) (grows #a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.map_has_at_index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) | [] | FStar.Monotonic.Seq.map_has_at_index_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.map_has_at_index r f n v)) | {
"end_col": 38,
"end_line": 289,
"start_col": 4,
"start_line": 289
} |
FStar.HyperStack.ST.ST | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a) | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k = | true | null | false | let h0 = HST.get () in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"Prims.nat",
"FStar.Monotonic.Seq.invariant",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"FStar.Seq.Base.index",
"FStar.Monotonic.Seq.i_sel",
"Prims.unit",
"FStar.Monotonic.Seq.i_at_least_is_stable",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a))) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True)) | [] | FStar.Monotonic.Seq.itest | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.Monotonic.Seq.rid ->
a: FStar.Monotonic.Seq.i_seq r Prims.nat FStar.Monotonic.Seq.invariant ->
k: Prims.nat
-> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 58,
"end_line": 186,
"start_col": 17,
"start_line": 183
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let test (i:rid) (l:rid) (a:Type0) (log:log_t l a) //(p:(nat -> Type))
(r:seqn i log 8) (h:mem)
= assert (HS.sel h r = Heap.sel (FStar.Map.sel (HS.get_hmap h) i) (HS.as_ref r)) | let test (i l: rid) (a: Type0) (log: log_t l a) (r: seqn i log 8) (h: mem) = | false | null | false | assert (HS.sel h r = Heap.sel (FStar.Map.sel (HS.get_hmap h) i) (HS.as_ref r)) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.Seq.seqn",
"FStar.Monotonic.HyperStack.mem",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.increases",
"FStar.Monotonic.Heap.sel",
"FStar.Map.sel",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.Monotonic.HyperStack.as_ref",
"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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init
let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
= reveal_opaque (`%grows) (grows #a);
recall c; recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n
let testify_seqn (#a:Type0) (#i:rid) (#l:rid) (#log:log_t l a) (#max:nat) (ctr:seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
h0==h1 /\
at_most_log_len (HS.sel h1 ctr) log h1))
= let n = !ctr in
testify (at_most_log_len n log)
private let test (i:rid) (l:rid) (a:Type0) (log:log_t l a) //(p:(nat -> Type)) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val test : i: FStar.Monotonic.Seq.rid ->
l: FStar.Monotonic.Seq.rid ->
a: Type0 ->
log: FStar.Monotonic.Seq.log_t l a ->
r: FStar.Monotonic.Seq.seqn i log 8 ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.unit | [] | FStar.Monotonic.Seq.test | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
i: FStar.Monotonic.Seq.rid ->
l: FStar.Monotonic.Seq.rid ->
a: Type0 ->
log: FStar.Monotonic.Seq.log_t l a ->
r: FStar.Monotonic.Seq.seqn i log 8 ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.unit | {
"end_col": 82,
"end_line": 435,
"start_col": 4,
"start_line": 435
} |
|
Prims.Tot | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last) | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s = | false | null | false | if Seq.length s = 0
then Seq.empty
else
let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Properties.snoc",
"FStar.Monotonic.Seq.map",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | [
"recursion"
] | FStar.Monotonic.Seq.map | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> Prims.Tot (FStar.Seq.Base.seq 'b) | {
"end_col": 39,
"end_line": 202,
"start_col": 2,
"start_line": 200
} |
FStar.Pervasives.Lemma | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
let collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) = | false | null | true | let aux: h0: mem -> h1: mem
-> Lemma
(collect_prefix r f bs h0 /\ grows (HS.sel h0 r) (HS.sel h1 r) ==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Classical.forall_intro_2",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"Prims.l_and",
"FStar.Monotonic.Seq.collect_prefix",
"FStar.Monotonic.HyperStack.sel",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Monotonic.Seq.collect_grows",
"FStar.HyperStack.ST.stable_on_t"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) | [] | FStar.Monotonic.Seq.collect_prefix_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.collect_prefix r f bs)) | {
"end_col": 22,
"end_line": 345,
"start_col": 3,
"start_line": 336
} |
FStar.Pervasives.Lemma | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a) | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
let i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) = | false | null | true | reveal_opaque (`%grows) (grows #a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.i_seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) | [] | FStar.Monotonic.Seq.i_at_least_is_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t m (FStar.Monotonic.Seq.i_at_least n x m)) | {
"end_col": 38,
"end_line": 121,
"start_col": 4,
"start_line": 121
} |
FStar.Pervasives.Lemma | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a) | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
let at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) = | false | null | true | reveal_opaque (`%grows) (grows #a) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) | [] | FStar.Monotonic.Seq.at_most_log_len_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t log (FStar.Monotonic.Seq.at_most_log_len x log)) | {
"end_col": 38,
"end_line": 386,
"start_col": 4,
"start_line": 386
} |
FStar.HyperStack.ST.ST | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let testify_seqn (#a:Type0) (#i:rid) (#l:rid) (#log:log_t l a) (#max:nat) (ctr:seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
h0==h1 /\
at_most_log_len (HS.sel h1 ctr) log h1))
= let n = !ctr in
testify (at_most_log_len n log) | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1))
let testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) = | true | null | false | let n = !ctr in
testify (at_most_log_len n log) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.log_t",
"Prims.nat",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.testify",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.unit",
"FStar.Monotonic.Seq.seqn_val",
"FStar.HyperStack.ST.op_Bang",
"FStar.Monotonic.Seq.increases",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init
let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
= reveal_opaque (`%grows) (grows #a);
recall c; recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n
let testify_seqn (#a:Type0) (#i:rid) (#l:rid) (#log:log_t l a) (#max:nat) (ctr:seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
h0==h1 /\ | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) | [] | FStar.Monotonic.Seq.testify_seqn | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | ctr: FStar.Monotonic.Seq.seqn i log max -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 35,
"end_line": 431,
"start_col": 3,
"start_line": 430
} |
FStar.Pervasives.Lemma | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2) | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
let collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) = | false | null | true | reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (requires (grows s1 s2))
(ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2)) =
if length s1 = length s2
then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2)
#(grows (collect f s1) (collect f s2))
(fun _ -> collect_grows_aux f s1 s2) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"FStar.Classical.arrow_to_impl",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.collect",
"Prims.squash",
"Prims.unit",
"FStar.Seq.Base.length",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_Equality",
"Prims.nat",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.l_True",
"Prims.l_imp"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) | [] | FStar.Monotonic.Seq.collect_grows | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s1: FStar.Seq.Base.seq 'a -> s2: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.grows s1 s2 ==>
FStar.Monotonic.Seq.grows (FStar.Monotonic.Seq.collect f s1)
(FStar.Monotonic.Seq.collect f s2)) | {
"end_col": 118,
"end_line": 325,
"start_col": 4,
"start_line": 315
} |
FStar.Pervasives.Lemma | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f) | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
let collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) = | false | null | true | reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"FStar.Monotonic.Seq.collect",
"FStar.Monotonic.Seq.collect_grows",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.collect_has_at_index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b) | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) | [] | FStar.Monotonic.Seq.collect_has_at_index_stable | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.collect_has_at_index r f n v)) | {
"end_col": 46,
"end_line": 360,
"start_col": 4,
"start_line": 359
} |
FStar.HyperStack.ST.ST | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r) | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
let write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) = | true | null | false | recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.at_least",
"Prims.unit",
"FStar.Seq.Properties.contains_snoc",
"FStar.Monotonic.Seq.at_least_is_stable",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Seq.Properties.snoc",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.HyperStack.ST.op_Bang",
"FStar.HyperStack.ST.recall",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.singleton",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel",
"FStar.HyperStack.ST.witnessed"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) | [] | FStar.Monotonic.Seq.write_at_end | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows -> x: a
-> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 33,
"end_line": 98,
"start_col": 4,
"start_line": 92
} |
FStar.Pervasives.Lemma | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
let rec map_append f s_1 s_2 = | false | null | true | if Seq.length s_2 = 0
then
(cut (Seq.equal (s_1 @ s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else
(let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1 @ s_2) (Seq.snoc (s_1 @ prefix_2) last));
map_snoc f (Seq.append s_1 prefix_2) last;
map_append f s_1 prefix_2;
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast) (m_s_1 @ Seq.snoc m_p_2 flast));
map_snoc f prefix_2 last) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Monotonic.Seq.op_At",
"FStar.Monotonic.Seq.map",
"Prims.unit",
"Prims.bool",
"FStar.Monotonic.Seq.map_snoc",
"FStar.Seq.Properties.snoc",
"FStar.Monotonic.Seq.map_append",
"FStar.Seq.Base.append",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1" | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | [
"recursion"
] | FStar.Monotonic.Seq.map_append | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> 'b) -> s1: FStar.Seq.Base.seq 'a -> s2: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.map f (s1 @ s2) ==
FStar.Monotonic.Seq.map f s1 @ FStar.Monotonic.Seq.map f s2)
(decreases FStar.Seq.Base.length s2) | {
"end_col": 33,
"end_line": 230,
"start_col": 2,
"start_line": 218
} |
FStar.Pervasives.Lemma | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 = | false | null | true | if Seq.length s1 = 0
then ()
else
let prefix, last = un_snoc s1 in
map_length f prefix | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Monotonic.Seq.map_length",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | [
"recursion"
] | FStar.Monotonic.Seq.map_length | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> 'b) -> s1: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.length s1 = FStar.Seq.Base.length (FStar.Monotonic.Seq.map f s1))
(decreases FStar.Seq.Base.length s1)
[SMTPat (FStar.Seq.Base.length (FStar.Monotonic.Seq.map f s1))] | {
"end_col": 26,
"end_line": 242,
"start_col": 2,
"start_line": 240
} |
FStar.HyperStack.ST.ST | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r) | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
let i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) = | true | null | false | recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r) | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"Prims.unit",
"FStar.Seq.Properties.contains_snoc",
"FStar.Monotonic.Seq.i_at_least_is_stable",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Seq.Properties.snoc",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.HyperStack.ST.op_Bang",
"FStar.HyperStack.ST.recall",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.i_sel",
"Prims.l_and",
"FStar.Monotonic.Seq.i_contains",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.singleton",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.eq2",
"FStar.HyperStack.ST.witnessed"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) | [] | FStar.Monotonic.Seq.i_write_at_end | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | r: FStar.Monotonic.Seq.i_seq rgn a p -> x: a -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 35,
"end_line": 160,
"start_col": 4,
"start_line": 154
} |
FStar.HyperStack.ST.ST | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i))
let new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i)) = | true | null | false | reveal_opaque (`%grows) (grows #a);
recall log;
recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.Seq.increases",
"FStar.HyperStack.ST.mref",
"Prims.unit",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.at_most_log_len",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.recall_region",
"FStar.HyperStack.ST.recall",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.empty",
"FStar.Monotonic.HyperStack.fresh_ref",
"Prims.op_Equality",
"FStar.Map.contains",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i)) | [] | FStar.Monotonic.Seq.new_seqn | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | i: FStar.Monotonic.Seq.rid -> init: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a
-> FStar.HyperStack.ST.ST (FStar.Monotonic.Seq.seqn i log max) | {
"end_col": 17,
"end_line": 404,
"start_col": 4,
"start_line": 401
} |
FStar.Pervasives.Lemma | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i = | false | null | true | if i = Seq.length s - 1
then ()
else
let prefix, last = un_snoc s in
map_index f prefix i | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.bool",
"FStar.Monotonic.Seq.map_index",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | false | false | FStar.Monotonic.Seq.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | [
"recursion"
] | FStar.Monotonic.Seq.map_index | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> i: Prims.nat{i < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.index (FStar.Monotonic.Seq.map f s) i == f (FStar.Seq.Base.index s i))
(decreases FStar.Seq.Base.length s)
[SMTPat (FStar.Seq.Base.index (FStar.Monotonic.Seq.map f s) i)] | {
"end_col": 27,
"end_line": 253,
"start_col": 2,
"start_line": 250
} |
FStar.HyperStack.ST.ST | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
= reveal_opaque (`%grows) (grows #a);
recall c; recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
let increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1)) = | true | null | false | reveal_opaque (`%grows) (grows #a);
recall c;
recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n | {
"checked_file": "FStar.Monotonic.Seq.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.Seq.increases",
"Prims.unit",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.int",
"Prims.op_Addition",
"FStar.HyperStack.ST.op_Bang",
"FStar.HyperStack.ST.recall",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_LessThanOrEqual",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.singleton",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.op_Equality"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init
let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\ | false | false | FStar.Monotonic.Seq.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1)) | [] | FStar.Monotonic.Seq.increment_seqn | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | $c: FStar.Monotonic.Seq.seqn i log max -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 10,
"end_line": 422,
"start_col": 4,
"start_line": 418
} |
Prims.Tot | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pts_to (#a:Type u#1) (r:ref a) (p:perm) (v:a) : vprop =
to_vprop (pts_to_sl r p v) | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop
let pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop = | false | null | false | to_vprop (pts_to_sl r p v) | {
"checked_file": "Steel.HigherReference.fsti.checked",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.HigherReference.fsti"
} | [
"total"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.HigherReference.pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open Steel.FractionalPermission
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
/// A library for Steel references with fractional permissions, storing values at universe 1
/// Under the hood, this library builds upon the PCM-based reference memory model in
/// Steel.PCMReference, by instantiating a specific fractional permission PCM
/// An abstract datatype for references
val ref ([@@@unused] a:Type u#1) : Type u#0
/// The null pointer
val null (#a:Type u#1) : ref a
/// Checking whether a pointer is null can be done in a decidable way
val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null})
/// The standard points to separation logic assertion, expressing that
/// reference [r] is valid in memory, stores value [v], and that we have
/// permission [p] on it.
val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector
[@@ __steel_reduce__] | false | false | Steel.HigherReference.fsti | {
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop | [] | Steel.HigherReference.pts_to | {
"file_name": "lib/steel/Steel.HigherReference.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | {
"end_col": 28,
"end_line": 49,
"start_col": 2,
"start_line": 49
} |
Prims.Tot | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ghost_pts_to (#a:_) (r:ghost_ref a) (p:perm) (x:a) : vprop =
to_vprop (ghost_pts_to_sl r p x) | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop
let ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop = | false | null | false | to_vprop (ghost_pts_to_sl r p x) | {
"checked_file": "Steel.HigherReference.fsti.checked",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.HigherReference.fsti"
} | [
"total"
] | [
"Steel.HigherReference.ghost_ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.HigherReference.ghost_pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open Steel.FractionalPermission
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
/// A library for Steel references with fractional permissions, storing values at universe 1
/// Under the hood, this library builds upon the PCM-based reference memory model in
/// Steel.PCMReference, by instantiating a specific fractional permission PCM
/// An abstract datatype for references
val ref ([@@@unused] a:Type u#1) : Type u#0
/// The null pointer
val null (#a:Type u#1) : ref a
/// Checking whether a pointer is null can be done in a decidable way
val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null})
/// The standard points to separation logic assertion, expressing that
/// reference [r] is valid in memory, stores value [v], and that we have
/// permission [p] on it.
val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector
[@@ __steel_reduce__]
unfold let pts_to (#a:Type u#1) (r:ref a) (p:perm) (v:a) : vprop =
to_vprop (pts_to_sl r p v)
/// If two pts_to predicates on the same reference [r] are valid in the memory [m],
/// then the two values [v0] and [v1] are identical
val pts_to_ref_injective
(#a: Type u#1)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
/// A valid pts_to predicate implies that the pointer is not the null pointer
val pts_to_not_null (#a:Type u#1)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
/// Exposing the is_witness_invariant from Steel.Memory for HigherReferences
val pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p))
/// A stateful version of the pts_to_ref_injective lemma above
val higher_ref_pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
/// Allocates a reference with value [x]. We have full permission on the newly
/// allocated reference.
val alloc (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r))
/// Reads the value in reference [r], as long as it initially is valid
val read (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v)
/// Atomic read
///
/// -- This is a little too powerful. We should only allow it on [t]'s
/// that are small enough. E.g., word-sized
val atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a)
(r:ref a)
: SteelAtomic a opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v)
/// A variant of read, useful when an existentially quantified predicate
/// depends on the value stored in the reference
val read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a)
: SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v))
(fun v -> pts_to r p v `star` q v)
/// Writes value [x] in the reference [r], as long as we have full ownership of [r]
val write (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
/// Atomic write, also requires full ownership of [r]
///
/// -- This is a little too powerful. We should only allow it on [t]'s
/// that are small enough. E.g., word-sized
val atomic_write (#opened:_) (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelAtomicT unit opened (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
/// Frees reference [r], as long as we have full ownership of [r]
val free (#a:Type) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp)
/// Splits the permission on reference [r] into two.
/// This function is computationally irrelevant (it has effect SteelGhost)
val share (#a:Type) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
/// Combines permissions on reference [r].
/// This function is computationally irrelevant (it has effect SteelGhost)
val gather (#a:Type) (#uses:_) (#p0:perm) (#p1:perm) (#v0 #v1:erased a) (r:ref a)
: SteelGhost unit uses
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r (sum_perm p0 p1) v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
/// Implementing cas as an action on references.
val cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:erased t)
(v_old:t)
(v_new:t)
: action_except (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
(*** Ghost references ***)
/// We also define a ghost variant of references, useful to do proofs relying on a ghost state
/// Ghost references are marked as erasable, ensuring that they are computationally irrelevant,
/// and only used in computationally irrelevant contexts.
/// The functions below are variants of the reference functions defined above,
/// but operating on ghost references, and with the computationally irrelevant SteelGhost effect
[@@ erasable]
val ghost_ref (a:Type u#1) : Type u#0
val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1
/// Lemmas to break the abstraction, if one needs to manipulate both
/// ghost and non-ghost references. These lemmas have no SMT patterns
/// so that the normalizer or SMT won't silently unfold the
/// definitions of ghost_ref or ghost_pts_to_sl. These should be
/// harmless since ghost_ref is erasable
val reveal_ghost_ref (a: Type u#1) : Lemma
(ghost_ref a == erased (ref a))
val reveal_ghost_pts_to_sl
(#a: _) (r: ghost_ref a) (p: perm) (x: a)
: Lemma
(ghost_pts_to_sl r p x == pts_to_sl (reveal (coerce_eq (reveal_ghost_ref a) r)) p x)
[@@ __steel_reduce__] | false | false | Steel.HigherReference.fsti | {
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop | [] | Steel.HigherReference.ghost_pts_to | {
"file_name": "lib/steel/Steel.HigherReference.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> p: Steel.FractionalPermission.perm -> x: a
-> Steel.Effect.Common.vprop | {
"end_col": 34,
"end_line": 191,
"start_col": 2,
"start_line": 191
} |
FStar.Pervasives.Lemma | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b)
let exp_mont_ladder_swap_lemma #t k a bBits b = | false | null | true | exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Exponentiation.exp_mont_ladder_swap_lemma_loop",
"Prims.unit"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b) | [] | Lib.Exponentiation.exp_mont_ladder_swap_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder_swap k a bBits b ==
Lib.Exponentiation.exp_mont_ladder k a bBits b) | {
"end_col": 56,
"end_line": 278,
"start_col": 2,
"start_line": 278
} |
FStar.Pervasives.Lemma | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b)
let exp_lr_lemma #t k a bBits b = | false | null | true | let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"Lib.Exponentiation.exp_lr_lemma_loop",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_lr_f",
"Lib.Exponentiation.Definition.one"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b) | [] | Lib.Exponentiation.exp_lr_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_lr k a bBits b == Lib.Exponentiation.Definition.pow k a b) | {
"end_col": 26,
"end_line": 151,
"start_col": 33,
"start_line": 147
} |
FStar.Pervasives.Lemma | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b))
let exp_pow2_lemma #t k a b = | false | null | true | exp_pow2_loop_lemma k a b b | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Lib.Exponentiation.exp_pow2_loop_lemma",
"Prims.unit"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b)) | [] | Lib.Exponentiation.exp_pow2_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Lib.Exponentiation.Definition.comm_monoid t -> a: t -> b: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_pow2 k a b == Lib.Exponentiation.Definition.pow k a (Prims.pow2 b)) | {
"end_col": 57,
"end_line": 296,
"start_col": 30,
"start_line": 296
} |
FStar.Pervasives.Lemma | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b)
let exp_mont_ladder_swap2_lemma #t k a bBits b = | false | null | true | exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Exponentiation.exp_mont_ladder_swap2_lemma_loop",
"Prims.unit"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b) | [] | Lib.Exponentiation.exp_mont_ladder_swap2_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder_swap2 k a bBits b ==
Lib.Exponentiation.exp_mont_ladder k a bBits b) | {
"end_col": 55,
"end_line": 251,
"start_col": 2,
"start_line": 251
} |
FStar.Pervasives.Lemma | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1) | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b)
let exp_mont_ladder_lemma #t k a bBits b = | false | null | true | let r0, r1 = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.exp_mont_ladder_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_mont_ladder_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Exponentiation.Definition.one"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b) | [] | Lib.Exponentiation.exp_mont_ladder_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder k a bBits b == Lib.Exponentiation.Definition.pow k a b) | {
"end_col": 26,
"end_line": 225,
"start_col": 43,
"start_line": 222
} |
FStar.Pervasives.Lemma | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits) | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b)
let exp_rl_lemma #t k a bBits b = | false | null | true | let acc, c = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Math.Lemmas.small_mod",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Modulus",
"Lib.Exponentiation.exp_rl_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_rl_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Exponentiation.Definition.one"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b) | [] | Lib.Exponentiation.exp_rl_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_rl k a bBits b == Lib.Exponentiation.Definition.pow k a b) | {
"end_col": 38,
"end_line": 96,
"start_col": 33,
"start_line": 92
} |
FStar.Pervasives.Lemma | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i = | false | null | true | if i = 0
then
(Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a)
else
(Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
()) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Lib.Exponentiation.Definition.lemma_pow1",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Lib.LoopCombinators.eq_repeat0",
"Lib.Exponentiation.Definition.sqr",
"Prims.bool",
"FStar.Math.Lemmas.pow2_double_sum",
"Prims.op_Subtraction",
"Lib.Exponentiation.Definition.lemma_pow_add",
"Lib.Exponentiation.exp_pow2_loop_lemma",
"Lib.LoopCombinators.unfold_repeat"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | [
"recursion"
] | Lib.Exponentiation.exp_pow2_loop_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Lib.Exponentiation.Definition.comm_monoid t -> a: t -> b: Prims.nat -> i: Prims.nat{i <= b}
-> FStar.Pervasives.Lemma
(ensures
Lib.LoopCombinators.repeat i (Lib.Exponentiation.Definition.sqr k) a ==
Lib.Exponentiation.Definition.pow k a (Prims.pow2 i)) | {
"end_col": 10,
"end_line": 294,
"start_col": 2,
"start_line": 285
} |
FStar.Pervasives.Lemma | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i = | false | null | true | assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Lib.Exponentiation.lemma_b_div_pow2ki",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | [] | Lib.Exponentiation.lemma_b_div_pow2i | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | bBits: Prims.nat -> b: Prims.nat{b < Prims.pow2 bBits} -> i: Prims.pos{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
b / Prims.pow2 (bBits - i) ==
(b / Prims.pow2 (bBits - i + 1)) * 2 + b / Prims.pow2 (bBits - i) % 2) | {
"end_col": 32,
"end_line": 47,
"start_col": 2,
"start_line": 46
} |
FStar.Pervasives.Lemma | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
} | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4)
let lemma_mul_assoc4 #t k a1 a2 a3 a4 = | false | null | true | calc ( == ) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
( == ) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
( == ) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
} | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__lemma_mul_assoc",
"Prims.squash"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1)
//-------------------------
val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | [] | Lib.Exponentiation.lemma_mul_assoc4 | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Lib.Exponentiation.Definition.comm_monoid t -> a1: t -> a2: t -> a3: t -> a4: t
-> FStar.Pervasives.Lemma
(ensures
Mkcomm_monoid?.mul k a1 (Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k a2 a3) a4) ==
Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k a1 a2) a3) a4) | {
"end_col": 3,
"end_line": 543,
"start_col": 2,
"start_line": 537
} |
Prims.Tot | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i) | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat
let b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat = | false | null | false | b / pow2 (bBits - bBits % l - l * i) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"total"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.op_Modulus",
"FStar.Mul.op_Star"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
} | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat | [] | Lib.Exponentiation.b_acc | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
l: Prims.pos ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits / l}
-> Prims.nat | {
"end_col": 38,
"end_line": 23,
"start_col": 2,
"start_line": 23
} |
FStar.Pervasives.Lemma | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1) | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2))
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l = | false | null | true | let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.exp_double_fw_lemma_loop",
"Prims.op_Division",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_double_fw_f",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.b_acc",
"Lib.Exponentiation.exp_double_fw_acc0_lemma",
"Prims.op_Modulus",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_double_fw_acc0"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2)) | [] | Lib.Exponentiation.exp_double_fw_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_double_fw k a1 bBits b1 a2 b2 l ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k a1 b1)
(Lib.Exponentiation.Definition.pow k a2 b2)) | {
"end_col": 26,
"end_line": 529,
"start_col": 50,
"start_line": 521
} |
FStar.Pervasives.Lemma | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b)
let exp_fw_lemma #t k a bBits b l = | false | null | true | let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.b_acc",
"Lib.Exponentiation.exp_fw_lemma_loop",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_fw_f",
"Lib.Exponentiation.exp_fw_acc0_aux_lemma",
"Prims.op_Modulus",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_fw_acc0"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b) | [] | Lib.Exponentiation.exp_fw_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_fw k a bBits b l == Lib.Exponentiation.Definition.pow k a b) | {
"end_col": 26,
"end_line": 404,
"start_col": 35,
"start_line": 393
} |
FStar.Pervasives.Lemma | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l = | false | null | true | if bBits % l = 0
then
let acc = one in
assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 ((bBits / l) * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 ((bBits / l) * l)));
()
else exp_fw_acc0_lemma #t k a bBits b l | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Mul.op_Star",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Math.Lemmas.small_div",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_fw_acc0_lemma"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | [] | Lib.Exponentiation.exp_fw_acc0_aux_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
(match bBits % l = 0 with
| true -> Lib.Exponentiation.Definition.one
| _ -> Lib.Exponentiation.exp_fw_acc0 k a bBits b l)
<:
t
in
acc0 == Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b 0))) | {
"end_col": 38,
"end_line": 390,
"start_col": 2,
"start_line": 381
} |
FStar.Pervasives.Lemma | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow k a2 b2)) (pow k a3 b3)) (pow k a4 b4)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_four_fw_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l;
assert (acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)));
k.lemma_mul_assoc (k.mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(pow k a3 b3_rem) (pow k a4 b4_rem);
Math.Lemmas.euclidean_division_definition bBits l;
let res =
Loops.repeati (bBits / l)
(exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (bBits / l);
assert_norm (pow2 0 = 1) | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow k a2 b2)) (pow k a3 b3)) (pow k a4 b4))
let exp_four_fw_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l = | false | null | true | let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
let acc0 = if bBits % l = 0 then one else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l;
assert (acc0 ==
mul (mul (pow k a1 b1_rem) (pow k a2 b2_rem)) (mul (pow k a3 b3_rem) (pow k a4 b4_rem)));
k.lemma_mul_assoc (k.mul (pow k a1 b1_rem) (pow k a2 b2_rem)) (pow k a3 b3_rem) (pow k a4 b4_rem);
Math.Lemmas.euclidean_division_definition bBits l;
let res = Loops.repeati (bBits / l) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (bBits / l);
assert_norm (pow2 0 = 1) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.exp_four_fw_lemma_loop",
"Prims.op_Division",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_four_fw_f",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__lemma_mul_assoc",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.Definition.pow",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.exp_four_fw_acc0_lemma",
"Prims.op_Modulus",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_four_fw_acc0",
"Lib.Exponentiation.b_acc"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1)
//-------------------------
val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4)
let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
}
val exp_four_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 (i - 1)))
(pow k a2 (b_acc l bBits b2 (i - 1))))
(pow k a3 (b_acc l bBits b3 (i - 1))))
(pow k a4 (b_acc l bBits b4 (i - 1))))
(ensures
exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1) acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 i))
(pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let exp_four_fw_lemma_step #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
let r31 = b_acc l bBits b3 (i - 1) in
let r32 = b_acc l bBits b3 i % pow2 l in
let r41 = b_acc l bBits b4 (i - 1) in
let r42 = b_acc l bBits b4 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
let res_a3 = pow k a3 (b_acc l bBits b3 i) in
let res_a4 = pow k a4 (b_acc l bBits b4 i) in
let acc_1 = pow k a1 r11 in
let acc_1_l = pow k acc_1 (pow2 l) in
let acc_12 = k.mul acc_1 (pow k a2 r21) in
let acc_12_l = pow k acc_12 (pow2 l) in
let acc_123 = k.mul acc_12 (pow k a3 r31) in
let acc_123_l = pow k acc_123 (pow2 l) in
calc (==) {
k.mul acc1 (pow k a4 r42);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a4 r42);
(==) { }
k.mul (pow k (k.mul acc_123 (pow k a4 r41)) (pow2 l)) (pow k a4 r42);
(==) { lemma_pow_mul_base k acc_123 (pow k a4 r41) (pow2 l) }
k.mul (k.mul acc_123_l (pow k (pow k a4 r41) (pow2 l))) (pow k a4 r42);
(==) { lemma_pow_distr_mul k acc_123_l a4 r41 r42 (pow2 l) }
k.mul (pow k a4 (r41 * pow2 l + r42)) acc_123_l;
(==) { lemma_b_div_pow2ki bBits b4 l i }
k.mul res_a4 acc_123_l;
};
calc (==) {
k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32);
(==) { }
k.mul (k.mul res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l))) (pow k a3 r32);
(==) {k.lemma_mul_assoc res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32)}
k.mul res_a4 (k.mul (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32));
(==) { lemma_pow_mul_base k acc_12 (pow k a3 r31) (pow2 l) }
k.mul res_a4 (k.mul (k.mul acc_12_l (pow k (pow k a3 r31) (pow2 l))) (pow k a3 r32));
(==) { lemma_pow_distr_mul k acc_12_l a3 r31 r32 (pow2 l) }
k.mul res_a4 (k.mul (pow k a3 (r31 * pow2 l + r32)) acc_12_l);
(==) { lemma_b_div_pow2ki bBits b3 l i }
k.mul res_a4 (k.mul res_a3 acc_12_l);
(==) { k.lemma_mul_assoc res_a4 res_a3 acc_12_l; k.lemma_mul_comm res_a4 res_a3 }
k.mul (k.mul res_a3 res_a4) acc_12_l;
};
let res_a234 = k.mul (k.mul res_a2 res_a3) res_a4 in
let res_a34 = k.mul res_a3 res_a4 in
calc (==) {
k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22);
(==) { }
k.mul (k.mul res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l))) (pow k a2 r22);
(==) { lemma_mul_assoc res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22) }
k.mul res_a34 (k.mul (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22));
(==) { lemma_pow_mul_base k acc_1 (pow k a2 r21) (pow2 l) }
k.mul res_a34 (k.mul (k.mul acc_1_l (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22));
(==) { lemma_pow_distr_mul k acc_1_l a2 r21 r22 (pow2 l) }
k.mul res_a34 (k.mul (pow k a2 (r21 * pow2 l + r22)) acc_1_l);
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a34 (k.mul res_a2 acc_1_l);
(==) { k.lemma_mul_assoc res_a34 res_a2 acc_1_l; k.lemma_mul_comm res_a34 res_a2 }
k.mul (k.mul res_a2 res_a34) acc_1_l;
(==) { k.lemma_mul_assoc res_a2 res_a3 res_a4 }
k.mul res_a234 acc_1_l;
};
calc (==) {
k.mul (k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a234 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a234 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a234;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 (k.mul (k.mul res_a2 res_a3) res_a4);
(==) { lemma_mul_assoc4 k res_a1 res_a2 res_a3 res_a4 }
k.mul (k.mul (k.mul res_a1 res_a2) res_a3) res_a4;
}
val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
acc ==
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0
else begin
Loops.unfold_repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1);
exp_four_fw_lemma_step k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc1;
() end
val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)))
let exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
if bBits % l = 0 then begin
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
Math.Lemmas.small_div b2 (pow2 bBits);
Math.Lemmas.small_div b3 (pow2 bBits);
Math.Lemmas.small_div b4 (pow2 bBits);
assert (b1_rem = 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_pow0 k a3;
lemma_pow0 k a4;
assert (
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)) ==
mul (mul one one) (mul one one));
lemma_one k.one;
() end
else begin
let acc_a1 = exp_fw_acc0 k a1 bBits b1 l in
let acc_a2 = exp_fw_acc0 k a2 bBits b2 l in
let acc_a3 = exp_fw_acc0 k a3 bBits b3 l in
let acc_a4 = exp_fw_acc0 k a4 bBits b4 l in
exp_fw_acc0_lemma k a1 bBits b1 l;
exp_fw_acc0_lemma k a2 bBits b2 l;
exp_fw_acc0_lemma k a3 bBits b3 l;
exp_fw_acc0_lemma k a4 bBits b4 l;
Math.Lemmas.euclidean_division_definition bBits l;
assert (acc_a1 == pow k a1 b1_rem);
assert (acc_a2 == pow k a2 b2_rem);
assert (acc_a3 == pow k a3 b3_rem);
assert (acc_a4 == pow k a4 b4_rem) end | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow k a2 b2)) (pow k a3 b3)) (pow k a4 b4)) | [] | Lib.Exponentiation.exp_four_fw_lemma | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul
(Lib.Exponentiation.Definition.pow k a1 b1)
(Lib.Exponentiation.Definition.pow k a2 b2))
(Lib.Exponentiation.Definition.pow k a3 b3))
(Lib.Exponentiation.Definition.pow k a4 b4)) | {
"end_col": 26,
"end_line": 780,
"start_col": 60,
"start_line": 758
} |
FStar.Pervasives.Lemma | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 = | false | null | true | let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == (b / pow2 (bBits - i)) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a ((b / pow2 (bBits - i)) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0)
then ()
else
(assert (acc == mul (pow k a ((b / pow2 (bBits - i)) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a ((b / pow2 (bBits - i)) * 2) 1;
()) | {
"checked_file": "Lib.Exponentiation.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.Exponentiation.fst"
} | [
"lemma"
] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow_add",
"FStar.Mul.op_Star",
"Lib.Exponentiation.Definition.lemma_pow1",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Addition",
"Lib.Exponentiation.lemma_b_div_pow2i",
"Lib.Exponentiation.exp_lr_f"
] | [] | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | false | false | Lib.Exponentiation.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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | [] | Lib.Exponentiation.exp_lr_lemma_step | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i < bBits} ->
acc1: t
-> FStar.Pervasives.Lemma
(requires acc1 == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i)))
(ensures
Lib.Exponentiation.exp_lr_f k a bBits b i acc1 ==
Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i - 1))) | {
"end_col": 10,
"end_line": 120,
"start_col": 45,
"start_line": 108
} |
Subsets and Splits