file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.FiniteMap.Ambient.fst | FStar.FiniteMap.Ambient.all_finite_map_facts_ambient | val all_finite_map_facts_ambient:squash (all_finite_map_facts u#b) | val all_finite_map_facts_ambient:squash (all_finite_map_facts u#b) | let all_finite_map_facts_ambient : squash (all_finite_map_facts u#b) =
all_finite_map_facts_lemma u#b () | {
"file_name": "ulib/FStar.FiniteMap.Ambient.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 43,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FiniteMap.Base.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.FiniteMap.Ambient.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.FiniteMap.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteMap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteMap",
"short_module": null
},
{
"abbrev": false,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.squash FStar.FiniteMap.Base.all_finite_map_facts | Prims.Tot | [
"total"
] | [] | [
"FStar.FiniteMap.Base.all_finite_map_facts_lemma"
] | [] | false | false | true | true | false | let all_finite_map_facts_ambient:squash (all_finite_map_facts u#b) =
| all_finite_map_facts_lemma u#b () | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fnegate5_lemma | val fnegate5_lemma (m:scale64_5) (a:felem5) (x:uint64) : Lemma
(requires (let (m0,m1,m2,m3,m4) = m in 2 * v x <= 4096 /\
m0 <= v x /\ m1 <= v x /\ m2 <= v x /\ m3 <= v x /\ m4 <= v x /\
felem_fits5 a m))
(ensures (let r = fnegate5 a x in let xn = v x in
as_nat5 r = 2 * v x * S.prime - as_nat5 a /\
... | val fnegate5_lemma (m:scale64_5) (a:felem5) (x:uint64) : Lemma
(requires (let (m0,m1,m2,m3,m4) = m in 2 * v x <= 4096 /\
m0 <= v x /\ m1 <= v x /\ m2 <= v x /\ m3 <= v x /\ m4 <= v x /\
felem_fits5 a m))
(ensures (let r = fnegate5 a x in let xn = v x in
as_nat5 r = 2 * v x * S.prime - as_nat5 a /\
... | let fnegate5_lemma m a x =
let xn = v x in
let (a0,a1,a2,a3,a4) = a in
let (m0,m1,m2,m3,m4) = m in
let r0 = u64 0xffffefffffc2f *. u64 2 *. x -. a0 in
assert_norm (0xffffefffffc2f < max52);
assert_norm (max52 < 0xffffefffffc2f * 2);
lemma_mul_sub m0 (u64 0xffffefffffc2f) x a0;
let r1 = u64 0xffffffffff... | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 216,
"start_col": 0,
"start_line": 163
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.che... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
a: Hacl.Spec.K256.Field52.Definitions.felem5 ->
x: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
(let _ = m in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ m0 m1 m2 m3 m4 = _ in
2 * Lib.IntTypes.v x <... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Prims.nat",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Lib.IntTy... | [] | false | false | true | false | false | let fnegate5_lemma m a x =
| let xn = v x in
let a0, a1, a2, a3, a4 = a in
let m0, m1, m2, m3, m4 = m in
let r0 = u64 0xffffefffffc2f *. u64 2 *. x -. a0 in
assert_norm (0xffffefffffc2f < max52);
assert_norm (max52 < 0xffffefffffc2f * 2);
lemma_mul_sub m0 (u64 0xffffefffffc2f) x a0;
let r1 = u64 0xfffffffffffff *. u64 2 *. x -. a1 in
assert_norm (... | false |
FStar.DependentMap.fst | FStar.DependentMap.sel | val sel (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) : Tot (value k) | val sel (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) : Tot (value k) | let sel (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) : Tot (value k) =
m.mappings k | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 27,
"start_col": 0,
"start_line": 26
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.DependentMap.t key value -> k: key -> value k | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.__proj__Mkt__item__mappings"
] | [] | false | false | false | false | false | let sel (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) : Tot (value k) =
| m.mappings k | false |
FStar.DependentMap.fst | FStar.DependentMap.create | val create (#key: eqtype) (#value: (key -> Tot Type)) (f: (k: key -> Tot (value k)))
: Tot (t key value) | val create (#key: eqtype) (#value: (key -> Tot Type)) (f: (k: key -> Tot (value k)))
: Tot (t key value) | let create (#key: eqtype) (#value: (key -> Tot Type)) (f: (k: key -> Tot (value k)))
: Tot (t key value) = { mappings = F.on_domain key f } | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 24,
"start_col": 0,
"start_line": 23
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (k: key -> value k) -> FStar.DependentMap.t key value | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.Mkt",
"FStar.FunctionalExtensionality.on_domain",
"FStar.DependentMap.t"
] | [] | false | false | false | false | false | let create (#key: eqtype) (#value: (key -> Tot Type)) (f: (k: key -> Tot (value k)))
: Tot (t key value) =
| { mappings = F.on_domain key f } | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.lemma_mul_sub_last | val lemma_mul_sub_last (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max48 /\ max48 <= v a * 2 /\ v c <= mc * max48 /\
mc <= v b /\ 2 * v b <= 65536)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits_last1 r (2 * v b))) | val lemma_mul_sub_last (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max48 /\ max48 <= v a * 2 /\ v c <= mc * max48 /\
mc <= v b /\ 2 * v b <= 65536)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits_last1 r (2 * v b))) | let lemma_mul_sub_last mc a b c =
let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max48);
ML.lemma_ab_le_cd mc max48 (v b) (v a * 2);
assert (v c <= v b * (v a * 2));
assert (v a * 2 * v b - v c <= v a * 2 * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max48 6553... | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 160,
"start_col": 0,
"start_line": 146
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.che... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | mc: Prims.nat -> a: Lib.IntTypes.uint64 -> b: Lib.IntTypes.uint64 -> c: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
Lib.IntTypes.v a <= Hacl.Spec.K256.Field52.Definitions.max48 /\
Hacl.Spec.K256.Field52.Definitions.max48 <= Lib.IntTypes.v a * 2 /\
Lib.IntTypes.v c <= mc * Hac... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.b2t",
"Hacl.Spec.K256.Field52.Definitions.felem_fits_last1",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.unit",
"Hacl.Spec.K256.MathLemmas.lemma_ab_le_cd",
"Hacl.Spec.K256.Field52.Definitions.... | [] | true | false | true | false | false | let lemma_mul_sub_last mc a b c =
| let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max48);
ML.lemma_ab_le_cd mc max48 (v b) (v a * 2);
assert (v c <= v b * (v a * 2));
assert ((v a * 2) * v b - v c <= (v a * 2) * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max48 65536;
assert_norm (65536 * max48 < pow2 64);
Mat... | false |
FStar.DependentMap.fst | FStar.DependentMap.equal | val equal (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value) : prop | val equal (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value) : prop | let equal (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value) =
forall k. sel m1 k == sel m2 k | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 51,
"start_col": 0,
"start_line": 50
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.DependentMap.t key value -> m2: FStar.DependentMap.t key value -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"Prims.l_Forall",
"Prims.eq2",
"FStar.DependentMap.sel",
"Prims.prop"
] | [] | false | false | false | false | true | let equal (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value) =
| forall k. sel m1 k == sel m2 k | false |
FStar.DependentMap.fst | FStar.DependentMap.upd | val upd (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) (v: value k)
: Tot (t key value) | val upd (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) (v: value k)
: Tot (t key value) | let upd (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) (v: value k)
: Tot (t key value) =
{ mappings = F.on_domain key (fun k' -> if k' = k then v else m.mappings k') } | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 36,
"start_col": 0,
"start_line": 34
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.DependentMap.t key value -> k: key -> v: value k -> FStar.DependentMap.t key value | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.Mkt",
"FStar.FunctionalExtensionality.on_domain",
"Prims.op_Equality",
"Prims.bool",
"FStar.DependentMap.__proj__Mkt__item__mappings"
] | [] | false | false | false | false | false | let upd (#key: eqtype) (#value: (key -> Tot Type)) (m: t key value) (k: key) (v: value k)
: Tot (t key value) =
| { mappings = F.on_domain key (fun k' -> if k' = k then v else m.mappings k') } | false |
FStar.DependentMap.fst | FStar.DependentMap.concat_mappings | val concat_mappings
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(#key2: eqtype)
(#value2: (key2 -> Tot Type))
(m1: (k1: key1 -> Tot (value1 k1)))
(m2: (k2: key2 -> Tot (value2 k2)))
(k: either key1 key2)
: concat_value value1 value2 k | val concat_mappings
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(#key2: eqtype)
(#value2: (key2 -> Tot Type))
(m1: (k1: key1 -> Tot (value1 k1)))
(m2: (k2: key2 -> Tot (value2 k2)))
(k: either key1 key2)
: concat_value value1 value2 k | let concat_mappings
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(#key2: eqtype)
(#value2: (key2 -> Tot Type))
(m1: (k1: key1 -> Tot (value1 k1)))
(m2: (k2: key2 -> Tot (value2 k2)))
(k: either key1 key2)
: concat_value value1 value2 k =
match k with
| Inl k1 -> m1 k1
... | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 82,
"start_col": 0,
"start_line": 71
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: (k1: key1 -> value1 k1) -> m2: (k2: key2 -> value2 k2) -> k: FStar.Pervasives.either key1 key2
-> FStar.DependentMap.concat_value value1 value2 k | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.Pervasives.either",
"FStar.DependentMap.concat_value"
] | [] | false | false | false | false | false | let concat_mappings
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(#key2: eqtype)
(#value2: (key2 -> Tot Type))
(m1: (k1: key1 -> Tot (value1 k1)))
(m2: (k2: key2 -> Tot (value2 k2)))
(k: either key1 key2)
: concat_value value1 value2 k =
| match k with
| Inl k1 -> m1 k1
| Inr k2 -> m2 k2 | false |
FStar.DependentMap.fst | FStar.DependentMap.restrict | val restrict (#key: eqtype) (#value: (key -> Tot Type)) (p: (key -> Tot Type0)) (m: t key value)
: Tot (t (k: key{p k}) value) | val restrict (#key: eqtype) (#value: (key -> Tot Type)) (p: (key -> Tot Type0)) (m: t key value)
: Tot (t (k: key{p k}) value) | let restrict (#key: eqtype) (#value: (key -> Tot Type)) (p: (key -> Tot Type0)) (m: t key value) =
{ mappings = F.on_domain (k: key{p k}) m.mappings } | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 61,
"start_col": 0,
"start_line": 60
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: key -> Type0) -> m: FStar.DependentMap.t key value
-> FStar.DependentMap.t (k: key{p k}) value | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.Mkt",
"FStar.FunctionalExtensionality.on_domain",
"FStar.DependentMap.__proj__Mkt__item__mappings"
] | [] | false | false | false | false | false | let restrict (#key: eqtype) (#value: (key -> Tot Type)) (p: (key -> Tot Type0)) (m: t key value) =
| { mappings = F.on_domain (k: key{p k}) m.mappings } | false |
FStar.DependentMap.fst | FStar.DependentMap.equal_elim | val equal_elim (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value)
: Lemma (requires (equal m1 m2)) (ensures (m1 == m2)) [SMTPat (equal m1 m2)] | val equal_elim (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value)
: Lemma (requires (equal m1 m2)) (ensures (m1 == m2)) [SMTPat (equal m1 m2)] | let equal_elim (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value) =
F.extensionality key value m1.mappings m2.mappings | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 58,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.DependentMap.t key value -> m2: FStar.DependentMap.t key value
-> FStar.Pervasives.Lemma (requires FStar.DependentMap.equal m1 m2)
(ensures m1 == m2)
[SMTPat (FStar.DependentMap.equal m1 m2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.FunctionalExtensionality.extensionality",
"FStar.DependentMap.__proj__Mkt__item__mappings",
"Prims.unit"
] | [] | true | false | true | false | false | let equal_elim (#key: eqtype) (#value: (key -> Tot Type)) (m1 m2: t key value) =
| F.extensionality key value m1.mappings m2.mappings | false |
FStar.DependentMap.fst | FStar.DependentMap.concat | val concat
(#key1: eqtype)
(#value1: (key1 -> Tot (Type u#v)))
(#key2: eqtype)
(#value2: (key2 -> Tot (Type u#v)))
(m1: t key1 value1)
(m2: t key2 value2)
: Tot (t (either key1 key2) (concat_value value1 value2)) | val concat
(#key1: eqtype)
(#value1: (key1 -> Tot (Type u#v)))
(#key2: eqtype)
(#value2: (key2 -> Tot (Type u#v)))
(m1: t key1 value1)
(m2: t key2 value2)
: Tot (t (either key1 key2) (concat_value value1 value2)) | let concat
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(#key2: eqtype)
(#value2: (key2 -> Tot Type))
(m1: t key1 value1)
(m2: t key2 value2)
: Tot (t (either key1 key2) (concat_value value1 value2)) =
{ mappings = F.on_domain (either key1 key2) (concat_mappings m1.mappings m2... | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 89,
"end_line": 92,
"start_col": 0,
"start_line": 84
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.DependentMap.t key1 value1 -> m2: FStar.DependentMap.t key2 value2
-> FStar.DependentMap.t (FStar.Pervasives.either key1 key2)
(FStar.DependentMap.concat_value value1 value2) | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.Mkt",
"FStar.Pervasives.either",
"FStar.DependentMap.concat_value",
"FStar.FunctionalExtensionality.on_domain",
"FStar.DependentMap.concat_mappings",
"FStar.DependentMap.__proj__Mkt__item__mappings"
] | [] | false | false | false | false | false | let concat
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(#key2: eqtype)
(#value2: (key2 -> Tot Type))
(m1: t key1 value1)
(m2: t key2 value2)
: Tot (t (either key1 key2) (concat_value value1 value2)) =
| { mappings = F.on_domain (either key1 key2) (concat_mappings m1.mappings m2.mappings) } | false |
FStar.DependentMap.fst | FStar.DependentMap.map | val map
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
: Tot (t key value2) | val map
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
: Tot (t key value2) | let map
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
: Tot (t key value2) = { mappings = F.on_domain key (fun k -> f k (sel m k)) } | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 137,
"start_col": 0,
"start_line": 132
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (k: key -> _: value1 k -> value2 k) -> m: FStar.DependentMap.t key value1
-> FStar.DependentMap.t key value2 | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.Mkt",
"FStar.FunctionalExtensionality.on_domain",
"FStar.DependentMap.sel"
] | [] | false | false | false | false | false | let map
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
: Tot (t key value2) =
| { mappings = F.on_domain key (fun k -> f k (sel m k)) } | false |
FStar.DependentMap.fst | FStar.DependentMap.map_upd | val map_upd
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
(k: key)
(v: value1 k)
: Lemma (ensures (map f (upd m k v) == upd (map f m) k (f k v)))
[
//AR: wanted to write an SMTPatOr, but gives some ... | val map_upd
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
(k: key)
(v: value1 k)
: Lemma (ensures (map f (upd m k v) == upd (map f m) k (f k v)))
[
//AR: wanted to write an SMTPatOr, but gives some ... | let map_upd
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
(k: key)
(v: value1 k)
= equal_elim #key #value2 (map f (upd m k v)) (upd (map f m) k (f k v)) | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 154,
"start_col": 0,
"start_line": 147
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: (k: key -> _: value1 k -> value2 k) ->
m: FStar.DependentMap.t key value1 ->
k: key ->
v: value1 k
-> FStar.Pervasives.Lemma
(ensures
FStar.DependentMap.map f (FStar.DependentMap.upd m k v) ==
FStar.DependentMap.upd (FStar.DependentMap.map f m) k (f k v))
[SMTPat (FStar... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.equal_elim",
"FStar.DependentMap.map",
"FStar.DependentMap.upd",
"Prims.unit"
] | [] | true | false | true | false | false | let map_upd
(#key: eqtype)
(#value1 #value2: (key -> Tot Type))
(f: (k: key -> value1 k -> Tot (value2 k)))
(m: t key value1)
(k: key)
(v: value1 k)
=
| equal_elim #key #value2 (map f (upd m k v)) (upd (map f m) k (f k v)) | false |
FStar.DependentMap.fst | FStar.DependentMap.rename | val rename
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(m: t key1 value1)
(#key2: eqtype)
(ren: (key2 -> Tot key1))
: Tot (t key2 (rename_value value1 ren)) | val rename
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(m: t key1 value1)
(#key2: eqtype)
(ren: (key2 -> Tot key1))
: Tot (t key2 (rename_value value1 ren)) | let rename
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(m: t key1 value1)
(#key2: eqtype)
(ren: (key2 -> Tot key1))
: Tot (t key2 (rename_value value1 ren)) =
{ mappings = F.on_domain key2 (fun k2 -> m.mappings (ren k2)) } | {
"file_name": "ulib/FStar.DependentMap.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 121,
"start_col": 0,
"start_line": 114
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.DependentMap.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.DependentMap.t key1 value1 -> ren: (_: key2 -> key1)
-> FStar.DependentMap.t key2 (FStar.DependentMap.rename_value value1 ren) | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.DependentMap.t",
"FStar.DependentMap.Mkt",
"FStar.FunctionalExtensionality.on_domain",
"FStar.DependentMap.__proj__Mkt__item__mappings",
"FStar.DependentMap.rename_value"
] | [] | false | false | false | false | false | let rename
(#key1: eqtype)
(#value1: (key1 -> Tot Type))
(m: t key1 value1)
(#key2: eqtype)
(ren: (key2 -> Tot key1))
: Tot (t key2 (rename_value value1 ren)) =
| { mappings = F.on_domain key2 (fun k2 -> m.mappings (ren k2)) } | false |
FStar.Math.Lib.fst | FStar.Math.Lib.shift_left | val shift_left: v:int -> i:nat -> Tot (res:int{res = v * (pow2 i)}) | val shift_left: v:int -> i:nat -> Tot (res:int{res = v * (pow2 i)}) | let shift_left v i =
v * (pow2 i) | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 97,
"start_col": 0,
"start_line": 96
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.int -> i: Prims.nat -> res: Prims.int{res = v * Prims.pow2 i} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.nat",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.b2t",
"Prims.op_Equality"
] | [] | false | false | false | false | false | let shift_left v i =
| v * (pow2 i) | false |
FStar.Math.Lib.fst | FStar.Math.Lib.arithmetic_shift_right | val arithmetic_shift_right: v:int -> i:nat -> Tot (res:int{ res = div v (pow2 i) }) | val arithmetic_shift_right: v:int -> i:nat -> Tot (res:int{ res = div v (pow2 i) }) | let arithmetic_shift_right v i =
div v (pow2 i) | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 102,
"start_col": 0,
"start_line": 101
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.int -> i: Prims.nat -> res: Prims.int{res = FStar.Math.Lib.div v (Prims.pow2 i)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.nat",
"FStar.Math.Lib.div",
"Prims.pow2",
"Prims.b2t",
"Prims.op_Equality"
] | [] | false | false | false | false | false | let arithmetic_shift_right v i =
| div v (pow2 i) | false |
FStar.Math.Lib.fst | FStar.Math.Lib.max | val max: x:int -> y:int -> Tot (z:int{ (x >= y ==> z = x) /\ (x < y ==> z = y) }) | val max: x:int -> y:int -> Tot (z:int{ (x >= y ==> z = x) /\ (x < y ==> z = y) }) | let max x y = if x >= y then x else y | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 70,
"start_col": 0,
"start_line": 70
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = x) /\ (x < y ==> z = y)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.bool",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_LessThan"
] | [] | false | false | false | false | false | let max x y =
| if x >= y then x else y | false |
FStar.Math.Lib.fst | FStar.Math.Lib.powx | val powx : x:int -> n:nat -> Tot int | val powx : x:int -> n:nat -> Tot int | let rec powx x n =
match n with
| 0 -> 1
| n -> x * powx x (n - 1) | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 62,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> n: Prims.nat -> Prims.int | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.nat",
"FStar.Mul.op_Star",
"FStar.Math.Lib.powx",
"Prims.op_Subtraction"
] | [
"recursion"
] | false | false | false | true | false | let rec powx x n =
| match n with
| 0 -> 1
| n -> x * powx x (n - 1) | false |
FStar.Math.Lib.fst | FStar.Math.Lib.slash_decr_axiom | val slash_decr_axiom: a:nat -> b:pos -> Lemma (a / b <= a) | val slash_decr_axiom: a:nat -> b:pos -> Lemma (a / b <= a) | let slash_decr_axiom a b =
mul_lemma 1 b a;
mul_div_lemma a b;
mul_lemma' (a / b) a b | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 38,
"start_col": 0,
"start_line": 35
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.nat -> b: Prims.pos -> FStar.Pervasives.Lemma (ensures a / b <= a) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.pos",
"FStar.Math.Lib.mul_lemma'",
"Prims.op_Division",
"Prims.unit",
"FStar.Math.Lib.mul_div_lemma",
"FStar.Math.Lib.mul_lemma"
] | [] | true | false | true | false | false | let slash_decr_axiom a b =
| mul_lemma 1 b a;
mul_div_lemma a b;
mul_lemma' (a / b) a b | false |
FStar.Math.Lib.fst | FStar.Math.Lib.log_2 | val log_2: x:pos -> Tot nat | val log_2: x:pos -> Tot nat | let rec log_2 x =
if x >= 2 then 1 + log_2 (x / 2) else 0 | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 55,
"start_col": 0,
"start_line": 54
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.pos -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Addition",
"FStar.Math.Lib.log_2",
"Prims.op_Division",
"Prims.bool",
"Prims.nat"
] | [
"recursion"
] | false | false | false | true | false | let rec log_2 x =
| if x >= 2 then 1 + log_2 (x / 2) else 0 | false |
FStar.Math.Lib.fst | FStar.Math.Lib.abs | val abs: x:int -> Tot (y:int{ (x >= 0 ==> y = x) /\ (x < 0 ==> y = -x) }) | val abs: x:int -> Tot (y:int{ (x >= 0 ==> y = x) /\ (x < 0 ==> y = -x) }) | let abs x = if x >= 0 then x else -x | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 66,
"start_col": 0,
"start_line": 66
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> y: Prims.int{(x >= 0 ==> y = x) /\ (x < 0 ==> y = - x)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.bool",
"Prims.op_Minus",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_LessThan"
] | [] | false | false | false | false | false | let abs x =
| if x >= 0 then x else - x | false |
FStar.Math.Lib.fst | FStar.Math.Lib.min | val min: x:int -> y:int -> Tot (z:int{ (x >= y ==> z = y) /\ (x < y ==> z = x) }) | val min: x:int -> y:int -> Tot (z:int{ (x >= y ==> z = y) /\ (x < y ==> z = x) }) | let min x y = if x >= y then y else x | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 74,
"start_col": 0,
"start_line": 74
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = y) /\ (x < y ==> z = x)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.bool",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_LessThan"
] | [] | false | false | false | false | false | let min x y =
| if x >= y then y else x | false |
FStar.Math.Lib.fst | FStar.Math.Lib.div_non_eucl | val div_non_eucl: a:int -> b:pos ->
Tot (q:int{ ( a >= 0 ==> q = a / b ) /\ ( a < 0 ==> q = -((-a)/b) ) }) | val div_non_eucl: a:int -> b:pos ->
Tot (q:int{ ( a >= 0 ==> q = a / b ) /\ ( a < 0 ==> q = -((-a)/b) ) }) | let div_non_eucl a b =
if a < 0 then 0 - ((0 - a) / b)
else a / b | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 92,
"start_col": 0,
"start_line": 90
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.int -> b: Prims.pos -> q: Prims.int{(a >= 0 ==> q = a / b) /\ (a < 0 ==> q = - (- a) / b)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.pos",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"Prims.op_Division",
"Prims.bool",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Equality",
"Prims.op_Minus"
] | [] | false | false | false | false | false | let div_non_eucl a b =
| if a < 0 then 0 - ((0 - a) / b) else a / b | false |
FStar.Math.Lib.fst | FStar.Math.Lib.div | val div: a:int -> b:pos -> Tot (c:int{(a < 0 ==> c < 0) /\ (a >= 0 ==> c >= 0)}) | val div: a:int -> b:pos -> Tot (c:int{(a < 0 ==> c < 0) /\ (a >= 0 ==> c >= 0)}) | let div a b =
if a < 0 then
begin
slash_decr_axiom (-a) b;
if a % b = 0 then - (-a / b)
else - (-a / b) - 1
end
else a / b | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 85,
"start_col": 0,
"start_line": 78
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.int -> b: Prims.pos -> c: Prims.int{(a < 0 ==> c < 0) /\ (a >= 0 ==> c >= 0)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.pos",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.op_Modulus",
"Prims.op_Minus",
"Prims.op_Division",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.unit",
"FStar.Math.Lib.slash_decr_axiom"
] | [] | false | false | false | false | false | let div a b =
| if a < 0
then
(slash_decr_axiom (- a) b;
if a % b = 0 then - (- a / b) else - (- a / b) - 1)
else a / b | false |
Version.fst | Version.everparse_version | val everparse_version : string | val everparse_version : string | let everparse_version = "00217c4a (unreleased)" | {
"file_name": "src/3d/Version.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 47,
"end_line": 2,
"start_col": 0,
"start_line": 2
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Version.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.string | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let everparse_version =
| "00217c4a (unreleased)" | false | |
Version.fst | Version.fstar_commit | val fstar_commit : string | val fstar_commit : string | let fstar_commit = "10183ea187" | {
"file_name": "src/3d/Version.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 3,
"start_col": 0,
"start_line": 3
} | module Version | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Version.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.string | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let fstar_commit =
| "10183ea187" | false |
Version.fst | Version.karamel_commit | val karamel_commit : string | val karamel_commit : string | let karamel_commit = "da1e941b" | {
"file_name": "src/3d/Version.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 4,
"start_col": 0,
"start_line": 4
} | module Version
let everparse_version = "00217c4a (unreleased)" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Version.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.string | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let karamel_commit =
| "da1e941b" | false |
FStar.Math.Lib.fst | FStar.Math.Lib.powx_lemma2 | val powx_lemma2: x:int -> n:nat -> m:nat -> Lemma
(powx x n * powx x m = powx x (n + m)) | val powx_lemma2: x:int -> n:nat -> m:nat -> Lemma
(powx x n * powx x m = powx x (n + m)) | let rec powx_lemma2 x n m =
let ass (x y z : int) : Lemma ((x*y)*z == x*(y*z)) = () in
match n with
| 0 -> ()
| _ -> powx_lemma2 x (n-1) m; ass x (powx x (n-1)) (powx x m) | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 63,
"end_line": 127,
"start_col": 0,
"start_line": 123
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> n: Prims.nat -> m: Prims.nat
-> FStar.Pervasives.Lemma
(ensures FStar.Math.Lib.powx x n * FStar.Math.Lib.powx x m = FStar.Math.Lib.powx x (n + m)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.int",
"Prims.nat",
"FStar.Math.Lib.powx",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Math.Lib.powx_lemma2",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.op_Multiply",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Mul.op_Star"
] | [
"recursion"
] | false | false | true | false | false | let rec powx_lemma2 x n m =
| let ass (x y z: int) : Lemma ((x * y) * z == x * (y * z)) = () in
match n with
| 0 -> ()
| _ ->
powx_lemma2 x (n - 1) m;
ass x (powx x (n - 1)) (powx x m) | false |
FStar.Math.Lib.fst | FStar.Math.Lib.op_Plus_Percent | val op_Plus_Percent : a:int -> p:pos ->
Tot (res:int{ (a >= 0 ==> res = a % p) /\ (a < 0 ==> res = -((-a) % p)) }) | val op_Plus_Percent : a:int -> p:pos ->
Tot (res:int{ (a >= 0 ==> res = a % p) /\ (a < 0 ==> res = -((-a) % p)) }) | let op_Plus_Percent a p = signed_modulo a p | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 113,
"start_col": 0,
"start_line": 113
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.int -> p: Prims.pos
-> res: Prims.int{(a >= 0 ==> res = a % p) /\ (a < 0 ==> res = - (- a) % p)} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.pos",
"FStar.Math.Lib.signed_modulo",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Equality",
"Prims.op_Modulus",
"Prims.op_LessThan",
"Prims.op_Minus"
] | [] | false | false | false | false | false | let ( +% ) a p =
| signed_modulo a p | false |
FStar.Math.Lib.fst | FStar.Math.Lib.signed_modulo | val signed_modulo: v:int -> p:pos -> Tot (res:int{ res = v - ((div_non_eucl v p) * p) }) | val signed_modulo: v:int -> p:pos -> Tot (res:int{ res = v - ((div_non_eucl v p) * p) }) | let signed_modulo v p =
if v >= 0 then v % p
else 0 - ( (0-v) % p) | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 109,
"start_col": 0,
"start_line": 107
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.int -> p: Prims.pos -> res: Prims.int{res = v - FStar.Math.Lib.div_non_eucl v p * p} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.pos",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Modulus",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Mul.op_Star",
"FStar.Math.Lib.div_non_eucl"
] | [] | false | false | false | false | false | let signed_modulo v p =
| if v >= 0 then v % p else 0 - ((0 - v) % p) | false |
FStar.Math.Lib.fst | FStar.Math.Lib.div_non_eucl_decr_lemma | val div_non_eucl_decr_lemma: a:int -> b:pos -> Lemma (abs (div_non_eucl a b) <= abs a) | val div_non_eucl_decr_lemma: a:int -> b:pos -> Lemma (abs (div_non_eucl a b) <= abs a) | let div_non_eucl_decr_lemma a b =
slash_decr_axiom (abs a) b | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 140,
"start_col": 0,
"start_line": 139
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.int -> b: Prims.pos
-> FStar.Pervasives.Lemma
(ensures FStar.Math.Lib.abs (FStar.Math.Lib.div_non_eucl a b) <= FStar.Math.Lib.abs a) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.int",
"Prims.pos",
"FStar.Math.Lib.slash_decr_axiom",
"FStar.Math.Lib.abs",
"Prims.unit"
] | [] | true | false | true | false | false | let div_non_eucl_decr_lemma a b =
| slash_decr_axiom (abs a) b | false |
FStar.Math.Lib.fst | FStar.Math.Lib.slash_star_axiom | val slash_star_axiom: a:nat -> b:pos -> c:nat -> Lemma
(requires (a * b = c))
(ensures (a = c / b)) | val slash_star_axiom: a:nat -> b:pos -> c:nat -> Lemma
(requires (a * b = c))
(ensures (a = c / b)) | let slash_star_axiom a b c =
lemma_div_def c b;
lemma_mul_minus_distr_l b a (c/b) | {
"file_name": "ulib/FStar.Math.Lib.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 50,
"start_col": 0,
"start_line": 48
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Math.Lib.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.nat -> b: Prims.pos -> c: Prims.nat
-> FStar.Pervasives.Lemma (requires a * b = c) (ensures a = c / b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.pos",
"FStar.Math.Lib.lemma_mul_minus_distr_l",
"Prims.op_Division",
"Prims.unit",
"FStar.Math.Lib.lemma_div_def"
] | [] | true | false | true | false | false | let slash_star_axiom a b c =
| lemma_div_def c b;
lemma_mul_minus_distr_l b a (c / b) | false |
Vale.Math.Poly2.Galois.fsti | Vale.Math.Poly2.Galois.min | val min : x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = y) /\ (x < y ==> z = x)} | let min = FStar.Math.Lib.min | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 21,
"start_col": 7,
"start_line": 21
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module I = Lib.IntTypes
module G = Spec.GaloisField
module P = Vale.Math.Poly2_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open FStar.Seq
(*
Connect Spec.GaloisField to Vale.Math.Poly2*
*)
val to_poly (#f:G.field) (e:G.felem f) : poly
val to_felem (f:G.field) (p:poly) : ... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Spec.GaloisField.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.M... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = y) /\ (x < y ==> z = x)} | Prims.Tot | [
"total"
] | [] | [
"FStar.Math.Lib.min"
] | [] | false | false | false | false | false | let min =
| FStar.Math.Lib.min | false | |
Vale.Math.Poly2.Galois.fsti | Vale.Math.Poly2.Galois.max | val max : x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = x) /\ (x < y ==> z = y)} | let max = FStar.Math.Lib.max | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 22,
"start_col": 7,
"start_line": 22
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module I = Lib.IntTypes
module G = Spec.GaloisField
module P = Vale.Math.Poly2_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open FStar.Seq
(*
Connect Spec.GaloisField to Vale.Math.Poly2*
*)
val to_poly (#f:G.field) (e:G.felem f) : poly
val to_felem (f:G.field) (p:poly) : ... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Spec.GaloisField.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.M... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = x) /\ (x < y ==> z = y)} | Prims.Tot | [
"total"
] | [] | [
"FStar.Math.Lib.max"
] | [] | false | false | false | false | false | let max =
| FStar.Math.Lib.max | false | |
Hacl.Impl.Blake2.Generic.fst | Hacl.Impl.Blake2.Generic.blake2_update_last | val blake2_update_last:
#al:Spec.alg
-> #ms:m_spec
-> blake2_update_block: blake2_update_block_st al ms
-> blake2_update_last_st al ms | val blake2_update_last:
#al:Spec.alg
-> #ms:m_spec
-> blake2_update_block: blake2_update_block_st al ms
-> blake2_update_last_st al ms | let blake2_update_last #al #ms blake2_update_block #len wv hash prev rem d =
let h0 = ST.get () in
[@inline_let]
let spec _ h1 = state_v h1 hash == Spec.blake2_update_last al (v prev) (v rem) h0.[|d|] (state_v h0 hash) in
salloc1 h0 (size_block al) (u8 0) (Ghost.hide (loc hash |+| loc wv)) spec
(fun last_bloc... | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Generic.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 117,
"end_line": 542,
"start_col": 0,
"start_line": 524
} | module Hacl.Impl.Blake2.Generic
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
open Hacl.Impl.Blake2.Co... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"L... | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Constants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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_el... | false | blake2_update_block: Hacl.Impl.Blake2.Generic.blake2_update_block_st al ms
-> Hacl.Impl.Blake2.Generic.blake2_update_last_st al ms | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Hacl.Impl.Blake2.Core.m_spec",
"Hacl.Impl.Blake2.Generic.blake2_update_block_st",
"Lib.IntTypes.size_t",
"Hacl.Impl.Blake2.Core.state_p",
"Spec.Blake2.Definitions.limb_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Spec.Blake2... | [] | false | false | false | false | false | let blake2_update_last #al #ms blake2_update_block #len wv hash prev rem d =
| let h0 = ST.get () in
[@@ inline_let ]let spec _ h1 =
state_v h1 hash == Spec.blake2_update_last al (v prev) (v rem) h0.[| d |] (state_v h0 hash)
in
salloc1 h0
(size_block al)
(u8 0)
(Ghost.hide (loc hash |+| loc wv))
spec
(fun last_block ->
let last = sub d (len -! rem) rem in
let h1 = ST.get (... | false |
Vale.Math.Poly2.Galois.fsti | Vale.Math.Poly2.Galois.irred_poly | val irred_poly (f: G.field) : poly | val irred_poly (f: G.field) : poly | let irred_poly (f:G.field) : poly =
let G.GF t irred = f in
monomial (I.bits t) +. to_poly #f irred | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Galois.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 19,
"start_col": 0,
"start_line": 17
} | module Vale.Math.Poly2.Galois
open FStar.Mul
module I = Lib.IntTypes
module G = Spec.GaloisField
module P = Vale.Math.Poly2_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open FStar.Seq
(*
Connect Spec.GaloisField to Vale.Math.Poly2*
*)
val to_poly (#f:G.field) (e:G.felem f) : poly
val to_felem (f:G.field) (p:poly) : ... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Spec.GaloisField.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.M... | [
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Galois.IntTypes",
"short_module": "GI"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": "D"
},
{
"abbrev": true,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": "PL"
},
{
"abbr... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Spec.GaloisField.field -> Vale.Math.Poly2_s.poly | Prims.Tot | [
"total"
] | [] | [
"Spec.GaloisField.field",
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.op_disEquality",
"Lib.IntTypes.U1",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Vale.Math.Poly2.op_Plus_Dot",
"Vale.Math.Poly2_s.monomial",
"Lib.IntTypes.bits",
"Vale.Math.Poly2.Galo... | [] | false | false | false | true | false | let irred_poly (f: G.field) : poly =
| let G.GF t irred = f in
monomial (I.bits t) +. to_poly #f irred | false |
Hacl.Impl.Blake2.Generic.fst | Hacl.Impl.Blake2.Generic.serialize_params_blake2b | val serialize_params_blake2b
(kk: size_t{v kk <= Spec.max_key Spec.Blake2B})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2B})
(p: blake2_params Spec.Blake2B)
(b: lbuffer (word_t Spec.Blake2B) 8ul)
: Stack unit
(requires
fun h ->
live h b /\ blake2_param... | val serialize_params_blake2b
(kk: size_t{v kk <= Spec.max_key Spec.Blake2B})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2B})
(p: blake2_params Spec.Blake2B)
(b: lbuffer (word_t Spec.Blake2B) 8ul)
: Stack unit
(requires
fun h ->
live h b /\ blake2_param... | let serialize_params_blake2b
(kk:size_t{v kk <= Spec.max_key Spec.Blake2B})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2B})
(p: blake2_params Spec.Blake2B)
(b: lbuffer (word_t Spec.Blake2B) 8ul)
: Stack unit
(requires fun h -> live h b /\
blake2_params_inv #Spec.Blake2B h p /\
... | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Generic.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 760,
"start_col": 0,
"start_line": 667
} | module Hacl.Impl.Blake2.Generic
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
open Hacl.Impl.Blake2.Co... | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"L... | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Constants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"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_el... | false |
kk:
Lib.IntTypes.size_t
{Lib.IntTypes.v kk <= Spec.Blake2.Definitions.max_key Spec.Blake2.Definitions.Blake2B} ->
nn:
Lib.IntTypes.size_t
{ 1 <= Lib.IntTypes.v nn /\
Lib.IntTypes.v nn <= Spec.Blake2.Definitions.max_output Spec.Blake2.Definitions.Blake2B } ->
p: Hacl.Im... | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Spec.Blake2.Definitions.max_key",
"Spec.Blake2.Definitions.Blake2B",
"Prims.l_and",
"Spec.Blake2.Definitions.max_output",
"Hacl.Impl.Blake2.Core.blake2_params",
"Lib.Buffe... | [] | false | true | false | false | false | let serialize_params_blake2b
(kk: size_t{v kk <= Spec.max_key Spec.Blake2B})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2B})
(p: blake2_params Spec.Blake2B)
(b: lbuffer (word_t Spec.Blake2B) 8ul)
: Stack unit
(requires
fun h ->
live h b /\ blake2_param... | let h0 = ST.get () in
[@@ inline_let ]let kk_shift_8 = shift_left (to_u64 kk) (size 8) in
[@@ inline_let ]let fanout_shift_16 = shift_left (to_u64 p.fanout) (size 16) in
[@@ inline_let ]let depth_shift_24 = shift_left (to_u64 p.depth) (size 24) in
[@@ inline_let ]let leaf_length_shift_32 = shift_left (to_u64 p.leaf_len... | false |
FStar.Char.fsti | FStar.Char.int_of_char | val int_of_char (c: char) : nat | val int_of_char (c: char) : nat | let int_of_char (c: char) : nat = U32.v (u32_of_char c) | {
"file_name": "ulib/FStar.Char.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 56,
"start_col": 0,
"start_line": 56
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Char.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: FStar.Char.char -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"FStar.Char.char",
"FStar.UInt32.v",
"FStar.Char.u32_of_char",
"Prims.nat"
] | [] | false | false | false | true | false | let int_of_char (c: char) : nat =
| U32.v (u32_of_char c) | false |
FStar.Char.fsti | FStar.Char.char_of_int | val char_of_int (i: nat{i < 0xd7ff \/ (i >= 0xe000 /\ i <= 0x10ffff)}) : char | val char_of_int (i: nat{i < 0xd7ff \/ (i >= 0xe000 /\ i <= 0x10ffff)}) : char | let char_of_int (i: nat{i < 0xd7ff \/ (i >= 0xe000 /\ i <= 0x10ffff)}) : char = char_of_u32 (U32.uint_to_t i) | {
"file_name": "ulib/FStar.Char.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 109,
"end_line": 57,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Char.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: Prims.nat{i < 0xd7ff \/ i >= 0xe000 /\ i <= 0x10ffff} -> FStar.Char.char | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThanOrEqual",
"FStar.Char.char_of_u32",
"FStar.UInt32.uint_to_t",
"FStar.Char.char"
] | [] | false | false | false | false | false | let char_of_int (i: nat{i < 0xd7ff \/ (i >= 0xe000 /\ i <= 0x10ffff)}) : char =
| char_of_u32 (U32.uint_to_t i) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.open_exp_freevars | val open_exp_freevars (e v: src_exp) (n: nat)
: Lemma
(ensures
((freevars e) `Set.subset` (freevars (open_exp' e v n))) /\
((freevars (open_exp' e v n)) `Set.subset` ((freevars e) `Set.union` (freevars v))))
(decreases e) | val open_exp_freevars (e v: src_exp) (n: nat)
: Lemma
(ensures
((freevars e) `Set.subset` (freevars (open_exp' e v n))) /\
((freevars (open_exp' e v n)) `Set.subset` ((freevars e) `Set.union` (freevars v))))
(decreases e) | let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBo... | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 142,
"start_col": 0,
"start_line": 109
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : ind... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fst... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 2,
"max_fuel": 4,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e: DependentBoolRefinement.src_exp -> v: DependentBoolRefinement.src_exp -> n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
FStar.Set.subset (DependentBoolRefinement.freevars e)
(DependentBoolRefinement.freevars (DependentBoolRefinement.open_exp' e v n)) /\
FStar.Set.subset (DependentB... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"open_exp_freevars",
"open_ty_freevars"
] | [
"DependentBoolRefinement.src_exp",
"Prims.nat",
"Prims.bool",
"DependentBoolRefinement.index",
"DependentBoolRefinement.var",
"DependentBoolRefinement.open_exp_freevars",
"Prims.unit",
"DependentBoolRefinement.src_ty",
"Prims.op_Addition",
"DependentBoolRefinement.open_ty_freevars",
"Prims.l_Tru... | [
"mutual recursion"
] | false | false | true | false | false | let rec open_exp_freevars (e v: src_exp) (n: nat)
: Lemma
(ensures
((freevars e) `Set.subset` (freevars (open_exp' e v n))) /\
((freevars (open_exp' e v n)) `Set.subset` ((freevars e) `Set.union` (freevars v))))
(decreases e) =
| match e with
| EBool _ | EBVar _ | EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1) | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.hash_len | val hash_len : a: Hacl.HMAC_DRBG.supported_alg
-> n: Lib.IntTypes.size_t{Lib.IntTypes.v n = Spec.Hash.Definitions.hash_length a} | let hash_len (a:supported_alg) = Hacl.Hash.Definitions.hash_len a | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 21,
"start_col": 0,
"start_line": 21
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.HMAC_DRBG.supported_alg
-> n: Lib.IntTypes.size_t{Lib.IntTypes.v n = Spec.Hash.Definitions.hash_length a} | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.Hash.Definitions.hash_len",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",... | [] | false | false | false | false | false | let hash_len (a: supported_alg) =
| Hacl.Hash.Definitions.hash_len a | false | |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.freeable | val freeable: #a:supported_alg -> st:state a -> Type0 | val freeable: #a:supported_alg -> st:state a -> Type0 | let freeable #a st =
let k:B.buffer uint8 = st.k in
let v:B.buffer uint8 = st.v in
let ctr:B.buffer size_t = st.reseed_counter in
B.freeable k /\ B.freeable v /\ B.freeable ctr | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 104,
"start_col": 0,
"start_line": 100
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | st: Hacl.HMAC_DRBG.state a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"Prims.l_and",
"LowStar.Monotonic.Buffer.freeable",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"LowStar.Buffer.trivial_preorder",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"LowStar.Buffer.buffer",
"Hacl.HMAC_DRBG.__proj__S... | [] | false | false | false | false | true | let freeable #a st =
| let k:B.buffer uint8 = st.k in
let v:B.buffer uint8 = st.v in
let ctr:B.buffer size_t = st.reseed_counter in
B.freeable k /\ B.freeable v /\ B.freeable ctr | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.instantiate | val instantiate: a:supported_alg -> instantiate_st a | val instantiate: a:supported_alg -> instantiate_st a | let instantiate a st
entropy_input_len entropy_input
nonce_len nonce
personalization_string_len personalization_string
=
match a with
| SHA1 ->
mk_instantiate Hacl.HMAC.compute_sha1 st
entropy_input_len entropy_input
nonce_len nonce
personalization_string_len personalization_string
... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 217,
"start_col": 0,
"start_line": 192
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.HMAC_DRBG.supported_alg -> Hacl.HMAC_DRBG.instantiate_st a | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.mk_instantiate",
"Spec.Hash.Definitions.SHA1",
"Hacl.HMAC.compute_sha1",
"Prims.unit",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.HMAC.compute_sha2_256",
"Spe... | [] | false | false | false | false | false | let instantiate
a
st
entropy_input_len
entropy_input
nonce_len
nonce
personalization_string_len
personalization_string
=
| match a with
| SHA1 ->
mk_instantiate Hacl.HMAC.compute_sha1
st
entropy_input_len
entropy_input
nonce_len
nonce
personalization_string_len
personalization_string
| SHA2_256 ->
mk_instantiate Hacl.HMAC.compute_sha2_256
st
entropy_input_len
entropy_input
nonce_len
nonce... | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.repr | val repr: #a:supported_alg -> st:state a -> h:HS.mem -> GTot (S.state a) | val repr: #a:supported_alg -> st:state a -> h:HS.mem -> GTot (S.state a) | let repr #a st h =
S.State (as_seq h st.k) (as_seq h st.v) (v (bget h st.reseed_counter 0)) | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 125,
"start_col": 0,
"start_line": 124
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | st: Hacl.HMAC_DRBG.state a -> h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot (Spec.HMAC_DRBG.state a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"FStar.Monotonic.HyperStack.mem",
"Spec.HMAC_DRBG.State",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.hash_len",
"Hacl.HMAC_DRBG.__proj__State__item__k",
"Hacl.HMAC_DRBG.__proj__State__item__v",
"Lib.IntType... | [] | false | false | false | false | false | let repr #a st h =
| S.State (as_seq h st.k) (as_seq h st.v) (v (bget h st.reseed_counter 0)) | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.footprint | val footprint: #a:supported_alg -> st:state a -> GTot B.loc | val footprint: #a:supported_alg -> st:state a -> GTot B.loc | let footprint #a st =
let k:B.buffer uint8 = st.k in
let v:B.buffer uint8 = st.v in
let ctr:B.buffer size_t = st.reseed_counter in
B.loc_addr_of_buffer k |+| B.loc_addr_of_buffer v |+| B.loc_addr_of_buffer ctr | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 80,
"end_line": 110,
"start_col": 0,
"start_line": 106
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | st: Hacl.HMAC_DRBG.state a -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"Lib.Buffer.op_Bar_Plus_Bar",
"LowStar.Monotonic.Buffer.loc_addr_of_buffer",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"LowStar.Buffer.trivial_preorder",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"LowStar.Buffer.buffer",
... | [] | false | false | false | false | false | let footprint #a st =
| let k:B.buffer uint8 = st.k in
let v:B.buffer uint8 = st.v in
let ctr:B.buffer size_t = st.reseed_counter in
B.loc_addr_of_buffer k |+| B.loc_addr_of_buffer v |+| B.loc_addr_of_buffer ctr | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.invariant | val invariant: #a:supported_alg -> st:state a -> h:HS.mem -> Type0 | val invariant: #a:supported_alg -> st:state a -> h:HS.mem -> Type0 | let invariant #a st h =
live h st.k /\ live h st.v /\ live h st.reseed_counter /\ (
// JP: the disjoint predicate from lib hardcodes loc_buffer instead of
// loc_addr_of_buffer, which prevents us from writing a proper free function
// (probably why it wasn't written here in the first place)... we add on top
/... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 90,
"end_line": 122,
"start_col": 0,
"start_line": 112
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | st: Hacl.HMAC_DRBG.state a -> h: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.__proj__State__item__k",
"Hacl.HMAC_DRBG.__proj__State__item__v",
"Lib.IntTypes.size_t",
"Hacl.HMAC_DRBG.__proj__Sta... | [] | false | false | false | false | true | let invariant #a st h =
| live h st.k /\ live h st.v /\ live h st.reseed_counter /\
(let k = st.k <: B.buffer uint8 in
let v = st.v <: B.buffer uint8 in
let ctr = st.reseed_counter <: B.buffer size_t in
let open B in all_disjoint [loc_addr_of_buffer k; loc_addr_of_buffer v; loc_addr_of_buffer ctr]) | false |
CQueue.Cell.fst | CQueue.Cell.intro_ccell | val intro_ccell
(#opened: _)
(#a: Type0)
(c: ccell_lvalue a)
: SteelGhost unit opened
(vptr (ccell_data c) `star` vptr (ccell_next c))
(fun _ -> ccell c)
(fun _ -> True)
(fun h res h' ->
h' (ccell c) == ({ vcell_data = h (vptr (ccell_data c)); vcell_next = h (vptr (ccell_next c))})
) | val intro_ccell
(#opened: _)
(#a: Type0)
(c: ccell_lvalue a)
: SteelGhost unit opened
(vptr (ccell_data c) `star` vptr (ccell_next c))
(fun _ -> ccell c)
(fun _ -> True)
(fun h res h' ->
h' (ccell c) == ({ vcell_data = h (vptr (ccell_data c)); vcell_next = h (vptr (ccell_next c))})
) | let intro_ccell
#opened #a c
=
intro_ccell_is_lvalue c;
reveal_star (vptr (ccell_data c)) (vptr (ccell_next c));
intro_vdep
(ccell_is_lvalue c)
(vptr (ccell_data c) `star` vptr (ccell_next c))
(ccell0 a);
intro_vrewrite
(ccell_is_lvalue c `vdep` ccell0 a)
(ccell_rewrite c);
change_slprop... | {
"file_name": "share/steel/examples/steel/CQueue.Cell.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 139,
"start_col": 0,
"start_line": 120
} | module CQueue.Cell
(* A Steel model of C cell structs *)
#push-options "--__no_positivity"
noeq
type mcell (a: Type0) = {
data: ref a;
next: ref (mcell a);
all_or_none_null: squash (is_null data == is_null next); // TODO: /\ freeable data /\ freeable next, if freeable is implemented as a pure space proposition ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.Cell.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: CQueue.Cell.ccell_lvalue a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"CQueue.Cell.ccell_lvalue",
"Steel.Effect.Atomic.change_slprop_rel",
"CQueue.Cell.ccell1",
"CQueue.Cell.ccell",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.eq2",
"Prims.prop",
"Steel.Memory.mem",
"FStar.Pervasives.assert_norm",
"Prims.op_Equals_Equal... | [] | false | true | false | false | false | let intro_ccell #opened #a c =
| intro_ccell_is_lvalue c;
reveal_star (vptr (ccell_data c)) (vptr (ccell_next c));
intro_vdep (ccell_is_lvalue c) ((vptr (ccell_data c)) `star` (vptr (ccell_next c))) (ccell0 a);
intro_vrewrite ((ccell_is_lvalue c) `vdep` (ccell0 a)) (ccell_rewrite c);
change_slprop_rel (ccell1 c)
(ccell c)
(fun x y -> x == y)
(fu... | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.reseed | val reseed: a:supported_alg -> reseed_st a | val reseed: a:supported_alg -> reseed_st a | let reseed a st
entropy_input_len entropy_input
additional_input_input_len additional_input_input =
match a with
| SHA1 ->
mk_reseed Hacl.HMAC.compute_sha1 st
entropy_input_len entropy_input
additional_input_input_len additional_input_input
| SHA2_256 ->
mk_reseed Hacl.HMAC.compute_sha2_25... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 257,
"start_col": 0,
"start_line": 238
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.HMAC_DRBG.supported_alg -> Hacl.HMAC_DRBG.reseed_st a | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.mk_reseed",
"Spec.Hash.Definitions.SHA1",
"Hacl.HMAC.compute_sha1",
"Prims.unit",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.HMAC.compute_sha2_256",
"Spec.Has... | [] | false | false | false | false | false | let reseed a st entropy_input_len entropy_input additional_input_input_len additional_input_input =
| match a with
| SHA1 ->
mk_reseed Hacl.HMAC.compute_sha1
st
entropy_input_len
entropy_input
additional_input_input_len
additional_input_input
| SHA2_256 ->
mk_reseed Hacl.HMAC.compute_sha2_256
st
entropy_input_len
entropy_input
additional_input_input_len
additional_input_input... | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.generate | val generate: a:supported_alg -> generate_st a | val generate: a:supported_alg -> generate_st a | let generate a output st n additional_input_len additional_input =
match a with
| SHA1 ->
mk_generate Hacl.HMAC.compute_sha1 output st n
additional_input_len additional_input
| SHA2_256 ->
mk_generate Hacl.HMAC.compute_sha2_256 output st n
additional_input_len additional_input
| SHA2_384... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 319,
"start_col": 0,
"start_line": 306
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.HMAC_DRBG.supported_alg -> Hacl.HMAC_DRBG.generate_st a | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Lib.Buffer.buffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.state",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Hacl.HMAC_DRBG.mk_generate",
"Spec.Hash.Definitions.SHA1",
"Hacl.HMAC.compute_sha1",
"Prims.bool",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.HMAC.compu... | [] | false | false | false | false | false | let generate a output st n additional_input_len additional_input =
| match a with
| SHA1 -> mk_generate Hacl.HMAC.compute_sha1 output st n additional_input_len additional_input
| SHA2_256 ->
mk_generate Hacl.HMAC.compute_sha2_256 output st n additional_input_len additional_input
| SHA2_384 ->
mk_generate Hacl.HMAC.compute_sha2_384 output st n additional_input_len additional_input
| ... | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.alloca | val alloca: a:supported_alg -> StackInline (state a)
(requires fun _ -> True)
(ensures fun h0 st h1 ->
B.modifies B.loc_none h0 h1 /\
B.fresh_loc (footprint st) h0 h1 /\
B.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint st)) /\
invariant st h1) | val alloca: a:supported_alg -> StackInline (state a)
(requires fun _ -> True)
(ensures fun h0 st h1 ->
B.modifies B.loc_none h0 h1 /\
B.fresh_loc (footprint st) h0 h1 /\
B.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint st)) /\
invariant st h1) | let alloca a =
let k =
match a with
| SHA1 -> create (hash_len SHA1) (u8 0)
| SHA2_256 -> create (hash_len SHA2_256) (u8 0)
| SHA2_384 -> create (hash_len SHA2_384) (u8 0)
| SHA2_512 -> create (hash_len SHA2_512) (u8 0)
in
let v =
match a with
| SHA1 -> create (hash_len SHA... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 143,
"start_col": 0,
"start_line": 127
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.HMAC_DRBG.supported_alg -> FStar.HyperStack.ST.StackInline (Hacl.HMAC_DRBG.state a) | FStar.HyperStack.ST.StackInline | [] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.State",
"Hacl.HMAC_DRBG.state",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.size_t",
"FStar.UInt32.__uint... | [] | false | true | false | false | false | let alloca a =
| let k =
match a with
| SHA1 -> create (hash_len SHA1) (u8 0)
| SHA2_256 -> create (hash_len SHA2_256) (u8 0)
| SHA2_384 -> create (hash_len SHA2_384) (u8 0)
| SHA2_512 -> create (hash_len SHA2_512) (u8 0)
in
let v =
match a with
| SHA1 -> create (hash_len SHA1) (u8 0)
| SHA2_256 -> create (hash_len SHA2... | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.update | val update: #a:supported_alg
-> hmac:HMAC.compute_st a
-> len:size_t
-> data:lbuffer uint8 len
-> k:lbuffer uint8 (hash_len a)
-> v:lbuffer uint8 (hash_len a)
-> Stack unit
(requires fun h0 ->
live h0 data /\ live h0 k /\ live h0 v /\
disjoint k v /\ disjoint k data /\ disjoint v data /\
hash_... | val update: #a:supported_alg
-> hmac:HMAC.compute_st a
-> len:size_t
-> data:lbuffer uint8 len
-> k:lbuffer uint8 (hash_len a)
-> v:lbuffer uint8 (hash_len a)
-> Stack unit
(requires fun h0 ->
live h0 data /\ live h0 k /\ live h0 v /\
disjoint k v /\ disjoint k data /\ disjoint v data /\
hash_... | let update #a hmac len data k v =
update_round hmac len data (u8 0) k v;
if len <> 0ul then
update_round hmac len data (u8 1) k v | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 88,
"start_col": 0,
"start_line": 85
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
hmac: Hacl.HMAC.compute_st a ->
len: Lib.IntTypes.size_t ->
data: Lib.Buffer.lbuffer Lib.IntTypes.uint8 len ->
k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.HMAC_DRBG.hash_len a) ->
v: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.HMAC_DRBG.hash_len a)
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC.compute_st",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.hash_len",
"Prims.op_disEquality",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t",
"Hacl.HMAC_DRBG.update_round",
"Lib.IntTypes.u8",
"Prims.unit",
"Prims.b... | [] | false | true | false | false | false | let update #a hmac len data k v =
| update_round hmac len data (u8 0) k v;
if len <> 0ul then update_round hmac len data (u8 1) k v | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.create_in | val create_in: a:supported_alg -> r:HS.rid -> ST (state a)
(requires fun _ -> is_eternal_region r)
(ensures fun h0 st h1 ->
B.modifies B.loc_none h0 h1 /\
B.fresh_loc (footprint st) h0 h1 /\
B.(loc_includes (loc_region_only true r)) (footprint st) /\
invariant st h1 /\
freeable st) | val create_in: a:supported_alg -> r:HS.rid -> ST (state a)
(requires fun _ -> is_eternal_region r)
(ensures fun h0 st h1 ->
B.modifies B.loc_none h0 h1 /\
B.fresh_loc (footprint st) h0 h1 /\
B.(loc_includes (loc_region_only true r)) (footprint st) /\
invariant st h1 /\
freeable st) | let create_in a r =
let k:B.buffer uint8 =
match a with
| SHA1 -> B.malloc r (u8 0) (hash_len SHA1)
| SHA2_256 -> B.malloc r (u8 0) (hash_len SHA2_256)
| SHA2_384 -> B.malloc r (u8 0) (hash_len SHA2_384)
| SHA2_512 -> B.malloc r (u8 0) (hash_len SHA2_512)
in
let v:B.buffer uint8 =
matc... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 161,
"start_col": 0,
"start_line": 145
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.HMAC_DRBG.supported_alg -> r: FStar.Monotonic.HyperHeap.rid
-> FStar.HyperStack.ST.ST (Hacl.HMAC_DRBG.state a) | FStar.HyperStack.ST.ST | [] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"FStar.Monotonic.HyperHeap.rid",
"Hacl.HMAC_DRBG.State",
"Hacl.HMAC_DRBG.state",
"LowStar.Buffer.buffer",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"LowStar.Buffer.malloc",
"FStar.UInt32.__uint_to_t",
"LowStar.Monotonic.Buffer.mbuffer",
"LowS... | [] | false | true | false | false | false | let create_in a r =
| let k:B.buffer uint8 =
match a with
| SHA1 -> B.malloc r (u8 0) (hash_len SHA1)
| SHA2_256 -> B.malloc r (u8 0) (hash_len SHA2_256)
| SHA2_384 -> B.malloc r (u8 0) (hash_len SHA2_384)
| SHA2_512 -> B.malloc r (u8 0) (hash_len SHA2_512)
in
let v:B.buffer uint8 =
match a with
| SHA1 -> B.malloc r (u8 0) (ha... | false |
FStar.DM4F.IntStore.fst | FStar.DM4F.IntStore.in_ | val in_ : x: FStar.DM4F.IntStore.id -> store: FStar.DM4F.IntStore.heap -> Prims.bool | let in_ (x:id) (store:heap) = x < length store | {
"file_name": "examples/dm4free/FStar.DM4F.IntStore.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 24,
"start_col": 0,
"start_line": 24
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.IntStore.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.DM4F.IntStore.id -> store: FStar.DM4F.IntStore.heap -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.IntStore.id",
"FStar.DM4F.IntStore.heap",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.int",
"Prims.bool"
] | [] | false | false | false | true | false | let in_ (x: id) (store: heap) =
| x < length store | false | |
DependentBoolRefinement.fst | DependentBoolRefinement.open_ty_freevars | val open_ty_freevars (t: src_ty) (v: src_exp) (n: nat)
: Lemma
(ensures
((freevars_ty t) `Set.subset` (freevars_ty (open_ty' t v n))) /\
((freevars_ty (open_ty' t v n)) `Set.subset` ((freevars_ty t) `Set.union` (freevars v))))
(decreases t) | val open_ty_freevars (t: src_ty) (v: src_exp) (n: nat)
: Lemma
(ensures
((freevars_ty t) `Set.subset` (freevars_ty (open_ty' t v n))) /\
((freevars_ty (open_ty' t v n)) `Set.subset` ((freevars_ty t) `Set.union` (freevars v))))
(decreases t) | let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBo... | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 142,
"start_col": 0,
"start_line": 109
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : ind... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fst... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 2,
"max_fuel": 4,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.src_exp -> n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
FStar.Set.subset (DependentBoolRefinement.freevars_ty t)
(DependentBoolRefinement.freevars_ty (DependentBoolRefinement.open_ty' t v n)) /\
FStar.Set.subset (Depend... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"open_exp_freevars",
"open_ty_freevars"
] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_exp",
"Prims.nat",
"DependentBoolRefinement.open_ty_freevars",
"Prims.op_Addition",
"Prims.unit",
"DependentBoolRefinement.open_exp_freevars",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"FStar.Set.subset",
"DependentBoolRefinem... | [
"mutual recursion"
] | false | false | true | false | false | let rec open_ty_freevars (t: src_ty) (v: src_exp) (n: nat)
: Lemma
(ensures
((freevars_ty t) `Set.subset` (freevars_ty (open_ty' t v n))) /\
((freevars_ty (open_ty' t v n)) `Set.subset` ((freevars_ty t) `Set.union` (freevars v))))
(decreases t) =
| match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e -> open_exp_freevars e v (n + 1) | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.free | val free: #a:supported_alg -> free_st a | val free: #a:supported_alg -> free_st a | let free #_ s =
let State k v ctr = s in
B.free (k <: B.buffer uint8);
B.free (v <: B.buffer uint8);
B.free (ctr <: B.buffer size_t) | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 325,
"start_col": 0,
"start_line": 321
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.HMAC_DRBG.free_st a | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC_DRBG.state",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.hash_len",
"Lib.IntTypes.size_t",
"FStar.UInt32.__uint_to_t",
"Prims.l_and",
"Lib.Buffer.disjoint",
"Lib.Buffer.MUT",
"LowStar.Monotonic.Buffer.free",
"LowStar.Buffer.trivial_pre... | [] | false | false | false | false | false | let free #_ s =
| let State k v ctr = s in
B.free (k <: B.buffer uint8);
B.free (v <: B.buffer uint8);
B.free (ctr <: B.buffer size_t) | false |
FStar.DM4F.IntStore.fst | FStar.DM4F.IntStore.get | val get: Prims.unit -> int_store (heap) | val get: Prims.unit -> int_store (heap) | let get () : int_store (heap) = fun store -> Some store, store | {
"file_name": "examples/dm4free/FStar.DM4F.IntStore.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.IntStore.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.DM4F.IntStore.int_store FStar.DM4F.IntStore.heap | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.DM4F.IntStore.heap",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.IntStore.int_store"
] | [] | false | false | false | true | false | let get () : int_store (heap) =
| fun store -> Some store, store | false |
FStar.DM4F.IntStore.fst | FStar.DM4F.IntStore.return_is | val return_is (a: Type) (x: a) : int_store a | val return_is (a: Type) (x: a) : int_store a | let return_is (a:Type) (x:a) : int_store a = fun store -> Some x, store | {
"file_name": "examples/dm4free/FStar.DM4F.IntStore.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.IntStore.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> x: a -> FStar.DM4F.IntStore.int_store a | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.IntStore.heap",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.IntStore.int_store"
] | [] | false | false | false | true | false | let return_is (a: Type) (x: a) : int_store a =
| fun store -> Some x, store | false |
FStar.DM4F.IntStore.fst | FStar.DM4F.IntStore.raise_impl | val raise_impl: Prims.unit -> int_store False | val raise_impl: Prims.unit -> int_store False | let raise_impl () : int_store False = fun store -> None, store | {
"file_name": "examples/dm4free/FStar.DM4F.IntStore.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 41,
"start_col": 0,
"start_line": 41
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.IntStore.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.DM4F.IntStore.int_store Prims.l_False | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.DM4F.IntStore.heap",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"Prims.l_False",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.IntStore.int_store"
] | [] | false | false | false | true | false | let raise_impl () : int_store False =
| fun store -> None, store | false |
FStar.DM4F.IntStore.fst | FStar.DM4F.IntStore.bind_is | val bind_is (a b: Type) (x: int_store a) (f: (a -> int_store b)) : int_store b | val bind_is (a b: Type) (x: int_store a) (f: (a -> int_store b)) : int_store b | let bind_is (a b : Type) (x:int_store a) (f: a -> int_store b) : int_store b =
fun store ->
let (z, store') = x store in
match z with
| None -> None, store'
| Some xa -> f xa store' | {
"file_name": "examples/dm4free/FStar.DM4F.IntStore.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 34,
"start_col": 0,
"start_line": 29
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.IntStore.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Perv... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Type ->
b: Type ->
x: FStar.DM4F.IntStore.int_store a ->
f: (_: a -> FStar.DM4F.IntStore.int_store b)
-> FStar.DM4F.IntStore.int_store b | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.IntStore.int_store",
"FStar.DM4F.IntStore.heap",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | true | false | let bind_is (a b: Type) (x: int_store a) (f: (a -> int_store b)) : int_store b =
| fun store ->
let z, store' = x store in
match z with
| None -> None, store'
| Some xa -> f xa store' | false |
CQueue.Cell.fst | CQueue.Cell.elim_ccell | val elim_ccell
(#opened: _)
(#a: Type0)
(c: ccell_ptrvalue a)
: SteelAtomic (ccell_lvalue a) opened
(ccell c)
(fun c' -> vptr (ccell_data c') `star` vptr (ccell_next c'))
(fun _ -> True)
(fun h c' h' ->
ccell_ptrvalue_is_null c == false /\
(c' <: ccell_ptrvalue a) == c /\
h (ccel... | val elim_ccell
(#opened: _)
(#a: Type0)
(c: ccell_ptrvalue a)
: SteelAtomic (ccell_lvalue a) opened
(ccell c)
(fun c' -> vptr (ccell_data c') `star` vptr (ccell_next c'))
(fun _ -> True)
(fun h c' h' ->
ccell_ptrvalue_is_null c == false /\
(c' <: ccell_ptrvalue a) == c /\
h (ccel... | let elim_ccell
#opened #a c
=
let c2 = elim_ccell_ghost c in
let c : ccell_lvalue a = c in
change_equal_slprop (vptr (ccell_data c2)) (vptr (ccell_data c));
change_equal_slprop (vptr (ccell_next c2)) (vptr (ccell_next c));
return c | {
"file_name": "share/steel/examples/steel/CQueue.Cell.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 173,
"start_col": 0,
"start_line": 166
} | module CQueue.Cell
(* A Steel model of C cell structs *)
#push-options "--__no_positivity"
noeq
type mcell (a: Type0) = {
data: ref a;
next: ref (mcell a);
all_or_none_null: squash (is_null data == is_null next); // TODO: /\ freeable data /\ freeable next, if freeable is implemented as a pure space proposition ... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.Cell.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: CQueue.Cell.ccell_ptrvalue a -> Steel.Effect.Atomic.SteelAtomic (CQueue.Cell.ccell_lvalue a) | Steel.Effect.Atomic.SteelAtomic | [] | [] | [
"Steel.Memory.inames",
"CQueue.Cell.ccell_ptrvalue",
"Steel.Effect.Atomic.return",
"CQueue.Cell.ccell_lvalue",
"Steel.Effect.Common.VStar",
"Steel.Reference.vptrp",
"CQueue.Cell.ccell_data",
"Steel.FractionalPermission.full_perm",
"CQueue.Cell.ccell_next",
"Steel.Effect.Common.vprop",
"Prims.uni... | [] | false | true | false | false | false | let elim_ccell #opened #a c =
| let c2 = elim_ccell_ghost c in
let c:ccell_lvalue a = c in
change_equal_slprop (vptr (ccell_data c2)) (vptr (ccell_data c));
change_equal_slprop (vptr (ccell_next c2)) (vptr (ccell_next c));
return c | false |
FStar.All.fst | FStar.All.all_pre | val all_pre : Type | let all_pre = all_pre_h heap | {
"file_name": "ulib/FStar.All.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 21,
"start_col": 0,
"start_line": 21
} | (*
Copyright 2008-2014 Nikhil Swamy and 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 appli... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Heap.fst.checked",
"FStar.Exn.fst.checked"
],
"interface_file": false,
"source_file": "FStar.All.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Exn",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.all_pre_h",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let all_pre =
| all_pre_h heap | false | |
FStar.All.fst | FStar.All.lift_state_all | val lift_state_all : a: Type -> wp: FStar.ST.st_wp a -> p: FStar.All.all_post a
-> FStar.Pervasives.st_pre_h FStar.Monotonic.Heap.heap | let lift_state_all (a : Type) (wp : st_wp a) (p : all_post a) = wp (fun a -> p (V a)) | {
"file_name": "ulib/FStar.All.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 92,
"end_line": 27,
"start_col": 7,
"start_line": 27
} | (*
Copyright 2008-2014 Nikhil Swamy and 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 appli... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Heap.fst.checked",
"FStar.Exn.fst.checked"
],
"interface_file": false,
"source_file": "FStar.All.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Exn",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> wp: FStar.ST.st_wp a -> p: FStar.All.all_post a
-> FStar.Pervasives.st_pre_h FStar.Monotonic.Heap.heap | Prims.Tot | [
"total"
] | [] | [
"FStar.ST.st_wp",
"FStar.All.all_post",
"FStar.Pervasives.V",
"FStar.Monotonic.Heap.heap",
"Prims.l_True",
"FStar.Pervasives.st_pre_h"
] | [] | false | false | false | true | false | let lift_state_all (a: Type) (wp: st_wp a) (p: all_post a) =
| wp (fun a -> p (V a)) | false | |
FStar.All.fst | FStar.All.all_post' | val all_post' : a: Type -> pre: Type -> Type | let all_post' (a : Type) (pre:Type) = all_post_h' heap a pre | {
"file_name": "ulib/FStar.All.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 22,
"start_col": 0,
"start_line": 22
} | (*
Copyright 2008-2014 Nikhil Swamy and 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 appli... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Heap.fst.checked",
"FStar.Exn.fst.checked"
],
"interface_file": false,
"source_file": "FStar.All.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Exn",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> pre: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.all_post_h'",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let all_post' (a pre: Type) =
| all_post_h' heap a pre | false | |
FStar.All.fst | FStar.All.all_post | val all_post : a: Type -> Type | let all_post (a : Type) = all_post_h heap a | {
"file_name": "ulib/FStar.All.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 23,
"start_col": 0,
"start_line": 23
} | (*
Copyright 2008-2014 Nikhil Swamy and 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 appli... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Heap.fst.checked",
"FStar.Exn.fst.checked"
],
"interface_file": false,
"source_file": "FStar.All.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Exn",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.all_post_h",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let all_post (a: Type) =
| all_post_h heap a | false | |
FStar.All.fst | FStar.All.all_wp | val all_wp : a: Type -> Type | let all_wp (a : Type) = all_wp_h heap a | {
"file_name": "ulib/FStar.All.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 24,
"start_col": 0,
"start_line": 24
} | (*
Copyright 2008-2014 Nikhil Swamy and 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 appli... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Heap.fst.checked",
"FStar.Exn.fst.checked"
],
"interface_file": false,
"source_file": "FStar.All.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Exn",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.all_wp_h",
"FStar.Monotonic.Heap.heap"
] | [] | false | false | false | true | true | let all_wp (a: Type) =
| all_wp_h heap a | false | |
FStar.All.fst | FStar.All.lift_exn_all | val lift_exn_all : a: Type -> wp: FStar.Pervasives.ex_wp a -> p: FStar.All.all_post a -> h: FStar.Monotonic.Heap.heap
-> FStar.Pervasives.ex_pre | let lift_exn_all (a : Type) (wp : ex_wp a) (p : all_post a) (h : heap) = wp (fun ra -> p ra h) | {
"file_name": "ulib/FStar.All.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 94,
"end_line": 31,
"start_col": 0,
"start_line": 31
} | (*
Copyright 2008-2014 Nikhil Swamy and 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 appli... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.ST.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Heap.fst.checked",
"FStar.Exn.fst.checked"
],
"interface_file": false,
"source_file": "FStar.All.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Exn",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> wp: FStar.Pervasives.ex_wp a -> p: FStar.All.all_post a -> h: FStar.Monotonic.Heap.heap
-> FStar.Pervasives.ex_pre | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.ex_wp",
"FStar.All.all_post",
"FStar.Monotonic.Heap.heap",
"FStar.Pervasives.result",
"Prims.l_True",
"FStar.Pervasives.ex_pre"
] | [] | false | false | false | true | false | let lift_exn_all (a: Type) (wp: ex_wp a) (p: all_post a) (h: heap) =
| wp (fun ra -> p ra h) | false | |
LListReverse.fst | LListReverse.push | val push (#l': Ghost.erased (list U64.t)) (#x: Ghost.erased llist_cell) (p p': ref llist_cell)
: STT unit ((llist l' p') `star` (pts_to p full_perm x)) (fun p' -> llist (x.value :: l') p) | val push (#l': Ghost.erased (list U64.t)) (#x: Ghost.erased llist_cell) (p p': ref llist_cell)
: STT unit ((llist l' p') `star` (pts_to p full_perm x)) (fun p' -> llist (x.value :: l') p) | let push
(#l': Ghost.erased (list U64.t))
(#x: Ghost.erased llist_cell)
(p: ref llist_cell)
(p': ref llist_cell)
: STT unit
(llist l' p' `star` pts_to p full_perm x)
(fun p' -> llist (x.value :: l') p)
=
// write p ({ read p with next = p' }); // weird Steel error
let x_ = read p in
write p ({ x_ ... | {
"file_name": "share/steel/tests/krml/LListReverse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 69,
"end_line": 92,
"start_col": 0,
"start_line": 78
} | module LListReverse
open Steel.ST.GenElim
open Steel.ST.Reference
open Steel.ST.Loops
module U64 = FStar.UInt64
let main () = C.EXIT_SUCCESS // dummy for compilation
noeq
type llist_cell = {
value: U64.t;
next: ref llist_cell;
}
[@@__reduce__]
let llist_nil
(p: ref llist_cell)
: Tot vprop
= pure (p == null)
... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Ghost.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "Steel.ST.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Reference",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: Steel.ST.Reference.ref LListReverse.llist_cell ->
p': Steel.ST.Reference.ref LListReverse.llist_cell
-> Steel.ST.Effect.STT Prims.unit | Steel.ST.Effect.STT | [] | [] | [
"FStar.Ghost.erased",
"Prims.list",
"FStar.UInt64.t",
"LListReverse.llist_cell",
"Steel.ST.Reference.ref",
"Steel.ST.Util.rewrite",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"LListReverse.llist_cons",
"LListReverse.__proj__Mkllist_cell__item__value",
"FSta... | [] | false | true | false | false | false | let push (#l': Ghost.erased (list U64.t)) (#x: Ghost.erased llist_cell) (p p': ref llist_cell)
: STT unit ((llist l' p') `star` (pts_to p full_perm x)) (fun p' -> llist (x.value :: l') p) =
| let x_ = read p in
write p ({ x_ with next = p' });
let x' = vpattern_replace (pts_to p full_perm) in
vpattern_rewrite (llist _) x'.next;
rewrite (llist_cons x.value (llist l') p) (llist (x.value :: l') p) | false |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.machine_state | val machine_state : Type | let machine_state = Ms.machine_state | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 17,
"start_col": 7,
"start_line": 17
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"ful... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_Semantics_s.machine_state"
] | [] | false | false | false | true | true | let machine_state =
| Ms.machine_state | false | |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.update_round | val update_round: #a:supported_alg
-> hmac:HMAC.compute_st a
-> len:size_t
-> data:lbuffer uint8 len
-> n:uint8
-> k:lbuffer uint8 (hash_len a)
-> v:lbuffer uint8 (hash_len a)
-> Stack unit
(requires fun h0 ->
live h0 k /\ live h0 v /\ live h0 data /\
disjoint k v /\
// HMAC input length mus... | val update_round: #a:supported_alg
-> hmac:HMAC.compute_st a
-> len:size_t
-> data:lbuffer uint8 len
-> n:uint8
-> k:lbuffer uint8 (hash_len a)
-> v:lbuffer uint8 (hash_len a)
-> Stack unit
(requires fun h0 ->
live h0 k /\ live h0 v /\ live h0 data /\
disjoint k v /\
// HMAC input length mus... | let update_round #a hmac len data n k v =
let h0 = ST.get() in
push_frame();
let input_len = hash_len a +! 1ul +! len in
let input = create input_len (u8 0) in
let k' = sub input 0ul (hash_len a) in
copy k' v;
if len <> 0ul then copy (sub input (hash_len a +! 1ul) len) data;
input.(hash_len a) <- n;
l... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 63,
"start_col": 0,
"start_line": 47
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
hmac: Hacl.HMAC.compute_st a ->
len: Lib.IntTypes.size_t ->
data: Lib.Buffer.lbuffer Lib.IntTypes.uint8 len ->
n: Lib.IntTypes.uint8 ->
k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.HMAC_DRBG.hash_len a) ->
v: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.HMAC_DRBG.hash_len a)
-> FStar.HyperSt... | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC.compute_st",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.hash_len",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Lib.Buffer.copy",
"Lib.Buffer.MUT",
"Spec.HMAC_DRBG.hmac_input_bound",
"Prims._assert",
"FStar... | [] | false | true | false | false | false | let update_round #a hmac len data n k v =
| let h0 = ST.get () in
push_frame ();
let input_len = hash_len a +! 1ul +! len in
let input = create input_len (u8 0) in
let k' = sub input 0ul (hash_len a) in
copy k' v;
if len <> 0ul then copy (sub input (hash_len a +! 1ul) len) data;
input.(hash_len a) <- n;
let h1 = ST.get () in
assert (Seq.equal (as_seq h1 input) (... | false |
Hacl.HMAC_DRBG.fst | Hacl.HMAC_DRBG.mk_reseed | val mk_reseed: #a:supported_alg -> hmac:HMAC.compute_st a -> reseed_st a | val mk_reseed: #a:supported_alg -> hmac:HMAC.compute_st a -> reseed_st a | let mk_reseed #a hmac st
entropy_input_len entropy_input
additional_input_len additional_input
=
let h0 = ST.get () in
push_frame();
let seed_material = create (entropy_input_len +! additional_input_len) (u8 0) in
copy (sub seed_material 0ul entropy_input_len) entropy_input;
copy (sub seed_material entrop... | {
"file_name": "code/drbg/Hacl.HMAC_DRBG.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 235,
"start_col": 0,
"start_line": 220
} | module Hacl.HMAC_DRBG
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Spec.Hash.Definitions
open Lib.IntTypes
open Lib.Buffer
module HS = FStar.HyperStack
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module HMAC = Hacl.HMAC
module S = Spec.HMAC_DRBG
friend Spec.HMAC_DRBG
unfold
let hash_len... | {
"checked_file": "/",
"dependencies": [
"Spec.HMAC_DRBG.fst.checked",
"Spec.HMAC_DRBG.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Spec.HMAC_DRBG",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.HMAC",
"short_module": "HMAC"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowSt... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | hmac: Hacl.HMAC.compute_st a -> Hacl.HMAC_DRBG.reseed_st a | Prims.Tot | [
"total"
] | [] | [
"Hacl.HMAC_DRBG.supported_alg",
"Hacl.HMAC.compute_st",
"Hacl.HMAC_DRBG.state",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.HMAC_DRBG.hash_len",
"FStar.UInt32.__uint_to_t",
"Prims.l_and",
"Lib.Buffer.disjoint",
"Lib.Buffer.MUT",
"FStar.HyperStack.ST.pop_frame",
"... | [] | false | false | false | false | false | let mk_reseed #a hmac st entropy_input_len entropy_input additional_input_len additional_input =
| let h0 = ST.get () in
push_frame ();
let seed_material = create (entropy_input_len +! additional_input_len) (u8 0) in
copy (sub seed_material 0ul entropy_input_len) entropy_input;
copy (sub seed_material entropy_input_len additional_input_len) additional_input;
let h1 = ST.get () in
LSeq.eq_intro (as_seq h1 seed_materi... | false |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.machine_eval_code | val machine_eval_code : c: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.Tot (FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state) | let machine_eval_code = Ms.machine_eval_code | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 19,
"start_col": 7,
"start_line": 19
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"ful... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.Tot (FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state) | Prims.Tot | [
"total",
""
] | [] | [
"Vale.X64.Machine_Semantics_s.machine_eval_code"
] | [] | false | false | false | true | false | let machine_eval_code =
| Ms.machine_eval_code | false | |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.code | val code : Type0 | let code = Ms.code | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 18,
"start_col": 7,
"start_line": 18
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"ful... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_Semantics_s.code"
] | [] | false | false | false | true | true | let code =
| Ms.code | false | |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.machine_state_equal | val machine_state_equal : s1: Vale.X64.StateLemmas.machine_state -> s2: Vale.X64.StateLemmas.machine_state -> Prims.logical | let machine_state_equal (s1 s2:machine_state) =
let open Vale.X64.Machine_Semantics_s in
s1.ms_ok == s2.ms_ok /\
F.feq s1.ms_regs s2.ms_regs /\
F.feq s1.ms_flags s2.ms_flags /\
s1.ms_heap == s2.ms_heap /\
s1.ms_stack == s2.ms_stack /\
s1.ms_stackTaint == s2.ms_stackTaint /\
s1.ms_trace == s2.ms_trace /\... | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 35,
"start_col": 0,
"start_line": 26
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s1: Vale.X64.StateLemmas.machine_state -> s2: Vale.X64.StateLemmas.machine_state -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.StateLemmas.machine_state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"FStar.FunctionalExtensionality.feq",
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item... | [] | false | false | false | true | true | let machine_state_equal (s1 s2: machine_state) =
| let open Vale.X64.Machine_Semantics_s in
s1.ms_ok == s2.ms_ok /\ F.feq s1.ms_regs s2.ms_regs /\ F.feq s1.ms_flags s2.ms_flags /\
s1.ms_heap == s2.ms_heap /\ s1.ms_stack == s2.ms_stack /\ s1.ms_stackTaint == s2.ms_stackTaint /\
s1.ms_trace == s2.ms_trace /\ True | false | |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.machine_state_eq | val machine_state_eq : s1: Vale.X64.StateLemmas.machine_state -> s2: Vale.X64.StateLemmas.machine_state -> Prims.logical | let machine_state_eq (s1 s2:machine_state) =
s1 == s2 | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 24,
"start_col": 0,
"start_line": 23
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s1: Vale.X64.StateLemmas.machine_state -> s2: Vale.X64.StateLemmas.machine_state -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.StateLemmas.machine_state",
"Prims.eq2",
"Prims.logical"
] | [] | false | false | false | true | true | let machine_state_eq (s1 s2: machine_state) =
| s1 == s2 | false | |
Vale.PPC64LE.StateLemmas.fst | Vale.PPC64LE.StateLemmas.lemma_load_buffer_read64 | val lemma_load_buffer_read64 (h:vale_heap) (b:buffer64) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem64 (buffer_addr b h + 8 * i) h)
[SMTPat (buffer_read b i h)] | val lemma_load_buffer_read64 (h:vale_heap) (b:buffer64) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem64 (buffer_addr b h + 8 * i) h)
[SMTPat (buffer_read b i h)] | let lemma_load_buffer_read64 h b i =
lemma_load_mem64 b i h | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 24,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | module Vale.PPC64LE.StateLemmas
open Vale.PPC64LE.Memory_Sems
open Vale.PPC64LE.Memory
#reset-options "--initial_fuel 2 --max_fuel 2"
let lemma_to_eval_reg s r = ()
let lemma_to_eval_vec s v = ()
let lemma_to_eval_maddr s m = ()
let lemma_to_eval_cmp_opr s o = ()
let lemma_to_valid_maddr64 s m = ()
let lemma_valid_m... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Memory_Sems.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.StateLemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory_Sems",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: Vale.PPC64LE.Memory.vale_heap -> b: Vale.PPC64LE.Memory.buffer64 -> i: Prims.int
-> FStar.Pervasives.Lemma (requires Vale.PPC64LE.Memory.valid_buffer_read h b i)
(ensures
Vale.PPC64LE.Memory.buffer_read b i h ==
Vale.PPC64LE.Memory.load_mem64 (Vale.PPC64LE.Memory.buffer_addr b h + 8 * i) h)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.PPC64LE.Memory.vale_heap",
"Vale.PPC64LE.Memory.buffer64",
"Prims.int",
"Vale.PPC64LE.Memory.lemma_load_mem64",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_load_buffer_read64 h b i =
| lemma_load_mem64 b i h | false |
Vale.PPC64LE.StateLemmas.fst | Vale.PPC64LE.StateLemmas.lemma_load_buffer_read128 | val lemma_load_buffer_read128 (h:vale_heap) (b:buffer128) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem128 (buffer_addr b h + 16 * i) h)
[SMTPat (buffer_read b i h)] | val lemma_load_buffer_read128 (h:vale_heap) (b:buffer128) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem128 (buffer_addr b h + 16 * i) h)
[SMTPat (buffer_read b i h)] | let lemma_load_buffer_read128 h b i =
lemma_load_mem128 b i h | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 37,
"start_col": 0,
"start_line": 36
} | module Vale.PPC64LE.StateLemmas
open Vale.PPC64LE.Memory_Sems
open Vale.PPC64LE.Memory
#reset-options "--initial_fuel 2 --max_fuel 2"
let lemma_to_eval_reg s r = ()
let lemma_to_eval_vec s v = ()
let lemma_to_eval_maddr s m = ()
let lemma_to_eval_cmp_opr s o = ()
let lemma_to_valid_maddr64 s m = ()
let lemma_valid_m... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Memory_Sems.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.StateLemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory_Sems",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: Vale.PPC64LE.Memory.vale_heap -> b: Vale.PPC64LE.Memory.buffer128 -> i: Prims.int
-> FStar.Pervasives.Lemma (requires Vale.PPC64LE.Memory.valid_buffer_read h b i)
(ensures
Vale.PPC64LE.Memory.buffer_read b i h ==
Vale.PPC64LE.Memory.load_mem128 (Vale.PPC64LE.Memory.buffer_addr b h + 16 * i) h... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.PPC64LE.Memory.vale_heap",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Memory.lemma_load_mem128",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_load_buffer_read128 h b i =
| lemma_load_mem128 b i h | false |
CDDL.Pulse.fst | CDDL.Pulse.impl_t_choice_none | val impl_t_choice_none (#t1 #t2: bounded_typ_gen None) (f1: impl_typ t1) (f2: impl_typ t2)
: Tot (impl_typ (t_choice t1 t2)) | val impl_t_choice_none (#t1 #t2: bounded_typ_gen None) (f1: impl_typ t1) (f2: impl_typ t2)
: Tot (impl_typ (t_choice t1 t2)) | let impl_t_choice_none // FIXME: WHY WHY WHY can F* not automatically infer t1 and t2 by reducing (reveal (hide None)) to None?
(#t1 #t2: bounded_typ_gen None)
(f1: impl_typ t1)
(f2: impl_typ t2)
: Tot (impl_typ (t_choice t1 t2))
= impl_t_choice #None #t1 #t2 f1 f2 | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 35,
"end_line": 87,
"start_col": 0,
"start_line": 82
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": false,
"full_module": "CDDL.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "CBOR.Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "CBO... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f1: CDDL.Pulse.impl_typ t1 -> f2: CDDL.Pulse.impl_typ t2
-> CDDL.Pulse.impl_typ (CDDL.Spec.t_choice t1 t2) | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.bounded_typ_gen",
"FStar.Pervasives.Native.None",
"CBOR.Spec.Type.raw_data_item",
"CDDL.Pulse.impl_typ",
"CDDL.Pulse.impl_t_choice",
"FStar.Ghost.hide",
"FStar.Pervasives.Native.option",
"CDDL.Spec.t_choice"
] | [] | false | false | false | false | false | let impl_t_choice_none (#t1 #t2: bounded_typ_gen None) (f1: impl_typ t1) (f2: impl_typ t2)
: Tot (impl_typ (t_choice t1 t2)) =
| impl_t_choice #None #t1 #t2 f1 f2 | false |
Vale.PPC64LE.StateLemmas.fst | Vale.PPC64LE.StateLemmas.lemma_load_mem_get128 | val lemma_load_mem_get128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures load_mem128 ptr (get_vale_heap h) == S.get_heap_val128 ptr (heap_get (coerce h)))
[SMTPat (load_mem128 ptr (get_vale_heap h))] | val lemma_load_mem_get128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures load_mem128 ptr (get_vale_heap h) == S.get_heap_val128 ptr (heap_get (coerce h)))
[SMTPat (load_mem128 ptr (get_vale_heap h))] | let lemma_load_mem_get128 h ptr =
equiv_load_mem128 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 31,
"start_col": 0,
"start_line": 28
} | module Vale.PPC64LE.StateLemmas
open Vale.PPC64LE.Memory_Sems
open Vale.PPC64LE.Memory
#reset-options "--initial_fuel 2 --max_fuel 2"
let lemma_to_eval_reg s r = ()
let lemma_to_eval_vec s v = ()
let lemma_to_eval_maddr s m = ()
let lemma_to_eval_cmp_opr s o = ()
let lemma_to_valid_maddr64 s m = ()
let lemma_valid_m... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Memory_Sems.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.StateLemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory_Sems",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: Vale.PPC64LE.Memory.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.PPC64LE.Memory.valid_mem128 ptr (Vale.PPC64LE.Memory.get_vale_heap h))
(ensures
Vale.PPC64LE.Memory.load_mem128 ptr (Vale.PPC64LE.Memory.get_vale_heap h) ==
Vale.Arch.MachineHeap_s.get_heap_val... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.PPC64LE.Memory.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.PPC64LE.Memory_Sems.lemma_heap_get_heap",
"Vale.PPC64LE.Memory_Sems.equiv_load_mem128",
"Vale.PPC64LE.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_load_mem_get128 h ptr =
| equiv_load_mem128 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | false |
Vale.PPC64LE.StateLemmas.fst | Vale.PPC64LE.StateLemmas.lemma_valid_mem_addr128 | val lemma_valid_mem_addr128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures S.valid_addr128 ptr (heap_get (coerce h)))
[SMTPat (valid_mem128 ptr (get_vale_heap h))] | val lemma_valid_mem_addr128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures S.valid_addr128 ptr (heap_get (coerce h)))
[SMTPat (valid_mem128 ptr (get_vale_heap h))] | let lemma_valid_mem_addr128 h ptr =
bytes_valid128 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 21,
"start_col": 0,
"start_line": 18
} | module Vale.PPC64LE.StateLemmas
open Vale.PPC64LE.Memory_Sems
open Vale.PPC64LE.Memory
#reset-options "--initial_fuel 2 --max_fuel 2"
let lemma_to_eval_reg s r = ()
let lemma_to_eval_vec s v = ()
let lemma_to_eval_maddr s m = ()
let lemma_to_eval_cmp_opr s o = ()
let lemma_to_valid_maddr64 s m = ()
let lemma_valid_m... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Memory_Sems.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.StateLemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory_Sems",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: Vale.PPC64LE.Memory.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.PPC64LE.Memory.valid_mem128 ptr (Vale.PPC64LE.Memory.get_vale_heap h))
(ensures
Vale.Arch.MachineHeap_s.valid_addr128 ptr
(Vale.Arch.Heap.heap_get (Vale.PPC64LE.Memory_Sems.coerce h)))
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.PPC64LE.Memory.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.PPC64LE.Memory_Sems.lemma_heap_get_heap",
"Vale.PPC64LE.Memory_Sems.bytes_valid128",
"Vale.PPC64LE.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_valid_mem_addr128 h ptr =
| bytes_valid128 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | false |
CDDL.Pulse.fst | CDDL.Pulse.impl_uint_literal | val impl_uint_literal (n: U64.t) : impl_typ (t_uint_literal n) | val impl_uint_literal (n: U64.t) : impl_typ (t_uint_literal n) | let impl_uint_literal
(n: U64.t)
: impl_typ (t_uint_literal n)
= impl_uint_literal' n | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 22,
"end_line": 175,
"start_col": 0,
"start_line": 172
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": false,
"full_module": "CDDL.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "C... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: FStar.UInt64.t -> CDDL.Pulse.impl_typ (CDDL.Spec.t_uint_literal n) | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt64.t",
"CDDL.Pulse.impl_uint_literal'",
"CDDL.Pulse.impl_typ",
"FStar.Pervasives.Native.None",
"CBOR.Spec.Type.raw_data_item",
"CDDL.Spec.t_uint_literal"
] | [] | false | false | false | false | false | let impl_uint_literal (n: U64.t) : impl_typ (t_uint_literal n) =
| impl_uint_literal' n | false |
Vale.PPC64LE.StateLemmas.fst | Vale.PPC64LE.StateLemmas.lemma_valid_mem_addr64 | val lemma_valid_mem_addr64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures S.valid_addr64 ptr (heap_get (coerce h)))
[SMTPat (valid_mem64 ptr (get_vale_heap h))] | val lemma_valid_mem_addr64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures S.valid_addr64 ptr (heap_get (coerce h)))
[SMTPat (valid_mem64 ptr (get_vale_heap h))] | let lemma_valid_mem_addr64 h ptr =
bytes_valid64 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 16,
"start_col": 0,
"start_line": 13
} | module Vale.PPC64LE.StateLemmas
open Vale.PPC64LE.Memory_Sems
open Vale.PPC64LE.Memory
#reset-options "--initial_fuel 2 --max_fuel 2"
let lemma_to_eval_reg s r = ()
let lemma_to_eval_vec s v = ()
let lemma_to_eval_maddr s m = ()
let lemma_to_eval_cmp_opr s o = ()
let lemma_to_valid_maddr64 s m = () | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Memory_Sems.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.StateLemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory_Sems",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: Vale.PPC64LE.Memory.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.PPC64LE.Memory.valid_mem64 ptr (Vale.PPC64LE.Memory.get_vale_heap h))
(ensures
Vale.Arch.MachineHeap_s.valid_addr64 ptr
(Vale.Arch.Heap.heap_get (Vale.PPC64LE.Memory_Sems.coerce h)))
[S... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.PPC64LE.Memory.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.PPC64LE.Memory_Sems.lemma_heap_get_heap",
"Vale.PPC64LE.Memory_Sems.bytes_valid64",
"Vale.PPC64LE.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_valid_mem_addr64 h ptr =
| bytes_valid64 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_with_typ_success_post | val cbor_read_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(c: cbor_read_t)
: Tot vprop | val cbor_read_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(c: cbor_read_t)
: Tot vprop | let cbor_read_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(c: cbor_read_t)
: Tot vprop
= exists* v rem.
raw_data_item_match full_perm c.cbor_read_payload v **
A.pts_to c.cbor_read_remainder #p rem **
((raw_data_item_match full_perm c.cbor_read_paylo... | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 59,
"end_line": 394,
"start_col": 0,
"start_line": 382
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: CDDL.Spec.typ ->
a: Pulse.Lib.Array.Core.array FStar.UInt8.t ->
p: PulseCore.FractionalPermission.perm ->
va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t) ->
c: CBOR.Pulse.Extern.cbor_read_t
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"Pulse.Lib.Array.Core.array",
"FStar.UInt8.t",
"PulseCore.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"CBOR.Pulse.Extern.cbor_read_t",
"Pulse.Lib.Core.op_exists_Star",
"CBOR.Spec.Type.raw_data_item",
"Pulse.Lib.Core.op_Star_Star",
"CBOR.Pulse.Extern.r... | [] | false | false | false | true | false | let cbor_read_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(c: cbor_read_t)
: Tot vprop =
| exists* v rem.
((raw_data_item_match full_perm c.cbor_read_payload v ** A.pts_to c.cbor_read_remainder #p rem) **
((raw_data_item_match full_perm c.cbor_read_payload v ** A.pts_to c.cbor_read_remainder #p rem) @==>
A.pts_to a #p va)) **
pure (cbor_read_with_typ_success_postcond t va c v rem) | false |
Vale.PPC64LE.StateLemmas.fst | Vale.PPC64LE.StateLemmas.lemma_load_mem_get64 | val lemma_load_mem_get64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures load_mem64 ptr (get_vale_heap h) == S.get_heap_val64 ptr (heap_get (coerce h)))
[SMTPat (load_mem64 ptr (get_vale_heap h))] | val lemma_load_mem_get64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures load_mem64 ptr (get_vale_heap h) == S.get_heap_val64 ptr (heap_get (coerce h)))
[SMTPat (load_mem64 ptr (get_vale_heap h))] | let lemma_load_mem_get64 h ptr =
equiv_load_mem64 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 26,
"start_col": 0,
"start_line": 23
} | module Vale.PPC64LE.StateLemmas
open Vale.PPC64LE.Memory_Sems
open Vale.PPC64LE.Memory
#reset-options "--initial_fuel 2 --max_fuel 2"
let lemma_to_eval_reg s r = ()
let lemma_to_eval_vec s v = ()
let lemma_to_eval_maddr s m = ()
let lemma_to_eval_cmp_opr s o = ()
let lemma_to_valid_maddr64 s m = ()
let lemma_valid_m... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Memory_Sems.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.StateLemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory_Sems",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: Vale.PPC64LE.Memory.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.PPC64LE.Memory.valid_mem64 ptr (Vale.PPC64LE.Memory.get_vale_heap h))
(ensures
Vale.PPC64LE.Memory.load_mem64 ptr (Vale.PPC64LE.Memory.get_vale_heap h) ==
Vale.Arch.MachineHeap_s.get_heap_val64... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.PPC64LE.Memory.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.PPC64LE.Memory_Sems.lemma_heap_get_heap",
"Vale.PPC64LE.Memory_Sems.equiv_load_mem64",
"Vale.PPC64LE.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_load_mem_get64 h ptr =
| equiv_load_mem64 ptr (get_vale_heap h);
lemma_heap_get_heap h;
() | false |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.coerce | val coerce (#b #a: Type) (x: a{a == b}) : b | val coerce (#b #a: Type) (x: a{a == b}) : b | let coerce (#b #a:Type) (x:a{a == b}) : b = x | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 21,
"start_col": 7,
"start_line": 21
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a{a == b} -> b | Prims.Tot | [
"total"
] | [] | [
"Prims.eq2"
] | [] | false | false | false | false | false | let coerce (#b #a: Type) (x: a{a == b}) : b =
| x | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_with_typ_post | val cbor_read_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop | val cbor_read_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop | let cbor_read_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop
= if res.cbor_read_is_success
then cbor_read_with_typ_success_post t a p va res
else cbor_read_with_typ_error_post t a p va | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 45,
"end_line": 438,
"start_col": 0,
"start_line": 429
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: CDDL.Spec.typ ->
a: Pulse.Lib.Array.Core.array FStar.UInt8.t ->
p: PulseCore.FractionalPermission.perm ->
va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t) ->
res: CBOR.Pulse.Extern.cbor_read_t
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"Pulse.Lib.Array.Core.array",
"FStar.UInt8.t",
"PulseCore.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"CBOR.Pulse.Extern.cbor_read_t",
"CBOR.Pulse.Extern.__proj__Mkcbor_read_t__item__cbor_read_is_success",
"CDDL.Pulse.cbor_read_with_typ_success_post",
"... | [] | false | false | false | true | false | let cbor_read_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop =
| if res.cbor_read_is_success
then cbor_read_with_typ_success_post t a p va res
else cbor_read_with_typ_error_post t a p va | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_with_typ_error_post | val cbor_read_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop | val cbor_read_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop | let cbor_read_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop
= A.pts_to a #p va ** pure (cbor_read_with_typ_error_postcond t va) | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 67,
"end_line": 427,
"start_col": 0,
"start_line": 421
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: CDDL.Spec.typ ->
a: Pulse.Lib.Array.Core.array FStar.UInt8.t ->
p: PulseCore.FractionalPermission.perm ->
va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t)
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"Pulse.Lib.Array.Core.array",
"FStar.UInt8.t",
"PulseCore.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Pulse.Lib.Core.op_Star_Star",
"Pulse.Lib.Array.Core.pts_to",
"FStar.Ghost.reveal",
"Pulse.Lib.Core.pure",
"CDDL.Pulse.cbor_read_with_typ_error_postc... | [] | false | false | false | true | false | let cbor_read_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop =
| A.pts_to a #p va ** pure (cbor_read_with_typ_error_postcond t va) | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_deterministically_encoded_with_typ_success_post | val cbor_read_deterministically_encoded_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop | val cbor_read_deterministically_encoded_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop | let cbor_read_deterministically_encoded_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop
= exists* v rem.
raw_data_item_match full_perm res.cbor_read_payload v **
A.pts_to res.cbor_read_remainder #p rem **
((r... | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 91,
"end_line": 544,
"start_col": 0,
"start_line": 532
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.U... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: CDDL.Spec.typ ->
a: Pulse.Lib.Array.Core.array FStar.UInt8.t ->
p: PulseCore.FractionalPermission.perm ->
va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t) ->
res: CBOR.Pulse.Extern.cbor_read_t
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"Pulse.Lib.Array.Core.array",
"FStar.UInt8.t",
"PulseCore.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"CBOR.Pulse.Extern.cbor_read_t",
"Pulse.Lib.Core.op_exists_Star",
"CBOR.Spec.Type.raw_data_item",
"Pulse.Lib.Core.op_Star_Star",
"CBOR.Pulse.Extern.r... | [] | false | false | false | true | false | let cbor_read_deterministically_encoded_with_typ_success_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop =
| exists* v rem.
((raw_data_item_match full_perm res.cbor_read_payload v ** A.pts_to res.cbor_read_remainder #p rem) **
((raw_data_item_match full_perm res.cbor_read_payload v ** A.pts_to res.cbor_read_remainder #p rem
) @==>
A.pts_to a #p va)) **
pure (cbor_read_deterministically_encoded_with_typ_success_p... | false |
CDDL.Pulse.fst | CDDL.Pulse.mk_cbor_read_error | val mk_cbor_read_error (res: cbor_read_t) : Tot cbor_read_t | val mk_cbor_read_error (res: cbor_read_t) : Tot cbor_read_t | let mk_cbor_read_error
(res: cbor_read_t)
: Tot cbor_read_t
= {res with cbor_read_is_success = false} | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 446,
"start_col": 0,
"start_line": 443
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.U... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | res: CBOR.Pulse.Extern.cbor_read_t -> CBOR.Pulse.Extern.cbor_read_t | Prims.Tot | [
"total"
] | [] | [
"CBOR.Pulse.Extern.cbor_read_t",
"CBOR.Pulse.Extern.Mkcbor_read_t",
"CBOR.Pulse.Extern.__proj__Mkcbor_read_t__item__cbor_read_payload",
"CBOR.Pulse.Extern.__proj__Mkcbor_read_t__item__cbor_read_remainder",
"CBOR.Pulse.Extern.__proj__Mkcbor_read_t__item__cbor_read_remainder_length"
] | [] | false | false | false | true | false | let mk_cbor_read_error (res: cbor_read_t) : Tot cbor_read_t =
| { res with cbor_read_is_success = false } | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_deterministically_encoded_with_typ_error_postcond | val cbor_read_deterministically_encoded_with_typ_error_postcond
(t: typ)
(va: Ghost.erased (Seq.seq U8.t))
: Tot prop | val cbor_read_deterministically_encoded_with_typ_error_postcond
(t: typ)
(va: Ghost.erased (Seq.seq U8.t))
: Tot prop | let cbor_read_deterministically_encoded_with_typ_error_postcond
(t: typ)
(va: Ghost.erased (Seq.seq U8.t))
: Tot prop
= forall v suff .
(Ghost.reveal va == serialize_cbor v `Seq.append` suff /\
data_item_wf deterministically_encoded_cbor_map_key_order v == true
) ==>
t v == false | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 514,
"start_col": 0,
"start_line": 506
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.U... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: CDDL.Spec.typ -> va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t) -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims.l_Forall",
"CBOR.Spec.Type.raw_data_item",
"CDDL.Spec.opt_precedes",
"FStar.Pervasives.Native.None",
"Prims.l_imp",
"Prims.l_and",
"Prims.eq2",
"FStar.Ghost.reveal",
"FStar.Seq.Base.append",
"CBOR.Spec.ser... | [] | false | false | false | true | true | let cbor_read_deterministically_encoded_with_typ_error_postcond
(t: typ)
(va: Ghost.erased (Seq.seq U8.t))
: Tot prop =
| forall v suff.
(Ghost.reveal va == (serialize_cbor v) `Seq.append` suff /\
data_item_wf deterministically_encoded_cbor_map_key_order v == true) ==>
t v == false | false |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.state_to_S | val state_to_S (s: vale_state) : GTot machine_state | val state_to_S (s: vale_state) : GTot machine_state | let state_to_S (s:vale_state) : GTot machine_state =
let open Ms in
{
ms_ok = s.vs_ok;
ms_regs = Regs.to_fun s.vs_regs;
ms_flags = Flags.to_fun s.vs_flags;
ms_heap = coerce s.vs_heap;
ms_stack = VSS.stack_to_s s.vs_stack;
ms_stackTaint = s.vs_stackTaint;
ms_trace = [];
} | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 52,
"start_col": 0,
"start_line": 42
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Vale.X64.State.vale_state -> Prims.GTot Vale.X64.StateLemmas.machine_state | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.State.vale_state",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.Regs.to_fun",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.Flags.to_fun",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.State... | [] | false | false | false | false | false | let state_to_S (s: vale_state) : GTot machine_state =
| let open Ms in
{
ms_ok = s.vs_ok;
ms_regs = Regs.to_fun s.vs_regs;
ms_flags = Flags.to_fun s.vs_flags;
ms_heap = coerce s.vs_heap;
ms_stack = VSS.stack_to_s s.vs_stack;
ms_stackTaint = s.vs_stackTaint;
ms_trace = []
} | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_with_typ_error_postcond | val cbor_read_with_typ_error_postcond (t: typ) (va: Ghost.erased (Seq.seq U8.t)) : Tot prop | val cbor_read_with_typ_error_postcond (t: typ) (va: Ghost.erased (Seq.seq U8.t)) : Tot prop | let cbor_read_with_typ_error_postcond
(t: typ)
(va: Ghost.erased (Seq.seq U8.t))
: Tot prop
= forall v suff .
Ghost.reveal va == serialize_cbor v `Seq.append` suff ==>
t v == false | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 403,
"start_col": 0,
"start_line": 397
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: CDDL.Spec.typ -> va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t) -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims.l_Forall",
"CBOR.Spec.Type.raw_data_item",
"CDDL.Spec.opt_precedes",
"FStar.Pervasives.Native.None",
"Prims.l_imp",
"Prims.eq2",
"FStar.Ghost.reveal",
"FStar.Seq.Base.append",
"CBOR.Spec.serialize_cbor",
"... | [] | false | false | false | true | true | let cbor_read_with_typ_error_postcond (t: typ) (va: Ghost.erased (Seq.seq U8.t)) : Tot prop =
| forall v suff. Ghost.reveal va == (serialize_cbor v) `Seq.append` suff ==> t v == false | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_deterministically_encoded_with_typ_error_post | val cbor_read_deterministically_encoded_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop | val cbor_read_deterministically_encoded_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop | let cbor_read_deterministically_encoded_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop
= A.pts_to a #p va ** pure (cbor_read_deterministically_encoded_with_typ_error_postcond t va) | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 93,
"end_line": 552,
"start_col": 0,
"start_line": 546
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.U... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: CDDL.Spec.typ ->
a: Pulse.Lib.Array.Core.array FStar.UInt8.t ->
p: PulseCore.FractionalPermission.perm ->
va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t)
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"Pulse.Lib.Array.Core.array",
"FStar.UInt8.t",
"PulseCore.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Pulse.Lib.Core.op_Star_Star",
"Pulse.Lib.Array.Core.pts_to",
"FStar.Ghost.reveal",
"Pulse.Lib.Core.pure",
"CDDL.Pulse.cbor_read_deterministically_en... | [] | false | false | false | true | false | let cbor_read_deterministically_encoded_with_typ_error_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
: Tot vprop =
| A.pts_to a #p va ** pure (cbor_read_deterministically_encoded_with_typ_error_postcond t va) | false |
Vale.X64.StateLemmas.fsti | Vale.X64.StateLemmas.state_of_S | val state_of_S (s: machine_state) : GTot vale_state | val state_of_S (s: machine_state) : GTot vale_state | let state_of_S (s:machine_state) : GTot vale_state =
let open Ms in
{
vs_ok = s.ms_ok;
vs_regs = Regs.of_fun s.ms_regs;
vs_flags = Flags.of_fun s.ms_flags;
vs_heap = coerce s.ms_heap;
vs_stack = VSS.stack_from_s s.ms_stack;
vs_stackTaint = s.ms_stackTaint;
} | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 63,
"start_col": 0,
"start_line": 54
} | module Vale.X64.StateLemmas
open Vale.X64.Machine_s
open Vale.Arch.Heap
open Vale.X64.State
open FStar.FunctionalExtensionality
module Ms = Vale.X64.Machine_Semantics_s
//open Vale.X64.Machine_Semantics_s
//module ME = Vale.X64.Memory
open Vale.X64.Memory
open Vale.Arch.MachineHeap_s
//module MS = Vale.X64.Memory_Sems
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Vale.X64.StateLemmas.machine_state -> Prims.GTot Vale.X64.State.vale_state | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.StateLemmas.machine_state",
"Vale.X64.State.Mkvale_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Regs.of_fun",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Flags.of_fun",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachin... | [] | false | false | false | false | false | let state_of_S (s: machine_state) : GTot vale_state =
| let open Ms in
{
vs_ok = s.ms_ok;
vs_regs = Regs.of_fun s.ms_regs;
vs_flags = Flags.of_fun s.ms_flags;
vs_heap = coerce s.ms_heap;
vs_stack = VSS.stack_from_s s.ms_stack;
vs_stackTaint = s.ms_stackTaint
} | false |
CDDL.Pulse.fst | CDDL.Pulse.cbor_read_deterministically_encoded_with_typ_post | val cbor_read_deterministically_encoded_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop | val cbor_read_deterministically_encoded_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop | let cbor_read_deterministically_encoded_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop
= if res.cbor_read_is_success
then cbor_read_deterministically_encoded_with_typ_success_post t a p va res
else cbor_read_deterministically_encoded_wit... | {
"file_name": "share/steel/examples/pulse/dice/cbor/CDDL.Pulse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 71,
"end_line": 563,
"start_col": 0,
"start_line": 554
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.SizeT.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Array",
"short_module": "A"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.U... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: CDDL.Spec.typ ->
a: Pulse.Lib.Array.Core.array FStar.UInt8.t ->
p: PulseCore.FractionalPermission.perm ->
va: FStar.Ghost.erased (FStar.Seq.Base.seq FStar.UInt8.t) ->
res: CBOR.Pulse.Extern.cbor_read_t
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"CDDL.Spec.typ",
"Pulse.Lib.Array.Core.array",
"FStar.UInt8.t",
"PulseCore.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"CBOR.Pulse.Extern.cbor_read_t",
"CBOR.Pulse.Extern.__proj__Mkcbor_read_t__item__cbor_read_is_success",
"CDDL.Pulse.cbor_read_deterministically_encoded_w... | [] | false | false | false | true | false | let cbor_read_deterministically_encoded_with_typ_post
(t: typ)
(a: A.array U8.t)
(p: perm)
(va: Ghost.erased (Seq.seq U8.t))
(res: cbor_read_t)
: Tot vprop =
| if res.cbor_read_is_success
then cbor_read_deterministically_encoded_with_typ_success_post t a p va res
else cbor_read_deterministically_encoded_with_typ_error_post t a p va | false |
MSort.SeqLemmas.fst | MSort.SeqLemmas.nil_app_l | val nil_app_l (#a: _) (s: S.seq a) : Lemma (S.append S.empty s == s) [SMTPat (S.append S.empty s)] | val nil_app_l (#a: _) (s: S.seq a) : Lemma (S.append S.empty s == s) [SMTPat (S.append S.empty s)] | let nil_app_l #a (s : S.seq a)
: Lemma (S.append S.empty s == s)
[SMTPat (S.append S.empty s)]
= S.append_empty_l s | {
"file_name": "share/steel/examples/pulse/MSort.SeqLemmas.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 22,
"end_line": 92,
"start_col": 0,
"start_line": 89
} | module MSort.SeqLemmas
open FStar.Ghost
module S = FStar.Seq
assume val sort : Seq.seq int -> Seq.seq int
assume val sorted : Seq.seq int -> bool
assume val sort_is_sorted (s:Seq.seq int) : Lemma (sorted (sort s))
assume val sort_len (s:Seq.seq int)
: Lemma (S.length (sort s) == S.length s)
[SMTPat (S.len... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"sho... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.append FStar.Seq.Base.empty s == s)
[SMTPat (FStar.Seq.Base.append FStar.Seq.Base.empty s)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append_empty_l",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.append",
"FStar.Seq.Base.empty",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let nil_app_l #a (s: S.seq a) : Lemma (S.append S.empty s == s) [SMTPat (S.append S.empty s)] =
| S.append_empty_l s | false |
MSort.SeqLemmas.fst | MSort.SeqLemmas.nil_app_r | val nil_app_r (#a: _) (s: S.seq a) : Lemma (S.append s S.empty == s) [SMTPat (S.append s S.empty)] | val nil_app_r (#a: _) (s: S.seq a) : Lemma (S.append s S.empty == s) [SMTPat (S.append s S.empty)] | let nil_app_r #a (s : S.seq a)
: Lemma (S.append s S.empty == s)
[SMTPat (S.append s S.empty)]
= S.append_empty_r s | {
"file_name": "share/steel/examples/pulse/MSort.SeqLemmas.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 22,
"end_line": 96,
"start_col": 0,
"start_line": 93
} | module MSort.SeqLemmas
open FStar.Ghost
module S = FStar.Seq
assume val sort : Seq.seq int -> Seq.seq int
assume val sorted : Seq.seq int -> bool
assume val sort_is_sorted (s:Seq.seq int) : Lemma (sorted (sort s))
assume val sort_len (s:Seq.seq int)
: Lemma (S.length (sort s) == S.length s)
[SMTPat (S.len... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"sho... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.append s FStar.Seq.Base.empty == s)
[SMTPat (FStar.Seq.Base.append s FStar.Seq.Base.empty)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append_empty_r",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.append",
"FStar.Seq.Base.empty",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let nil_app_r #a (s: S.seq a) : Lemma (S.append s S.empty == s) [SMTPat (S.append s S.empty)] =
| S.append_empty_r s | false |
MSort.SeqLemmas.fst | MSort.SeqLemmas.merge | val merge : Seq.seq int -> Seq.seq int -> Seq.seq int | val merge : Seq.seq int -> Seq.seq int -> Seq.seq int | let rec merge s1 s2 : Tot (S.seq int) (decreases S.length s1 + S.length s2) =
match view s1, view s2 with
| Nil, Nil -> S.empty
| Nil, Cons h t -> S.cons h t
| Cons h t, Nil -> S.cons h t
| Cons h1 t1, Cons h2 t2 ->
if h1 <= h2 then S.cons h1 (merge t1 s2) else S.cons h2 (merge s1 t2) | {
"file_name": "share/steel/examples/pulse/MSort.SeqLemmas.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 73,
"end_line": 31,
"start_col": 0,
"start_line": 25
} | module MSort.SeqLemmas
open FStar.Ghost
module S = FStar.Seq
assume val sort : Seq.seq int -> Seq.seq int
assume val sorted : Seq.seq int -> bool
assume val sort_is_sorted (s:Seq.seq int) : Lemma (sorted (sort s))
assume val sort_len (s:Seq.seq int)
: Lemma (S.length (sort s) == S.length s)
[SMTPat (S.len... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"sho... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s1: FStar.Seq.Base.seq Prims.int -> s2: FStar.Seq.Base.seq Prims.int
-> Prims.Tot (FStar.Seq.Base.seq Prims.int) | Prims.Tot | [
"",
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"FStar.Pervasives.Native.Mktuple2",
"MSort.SeqLemmas.seq_view",
"MSort.SeqLemmas.view",
"FStar.Seq.Base.empty",
"FStar.Seq.Base.cons",
"Prims.op_LessThanOrEqual",
"MSort.SeqLemmas.merge",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec merge s1 s2 : Tot (S.seq int) (decreases S.length s1 + S.length s2) =
| match view s1, view s2 with
| Nil, Nil -> S.empty
| Nil, Cons h t -> S.cons h t
| Cons h t, Nil -> S.cons h t
| Cons h1 t1, Cons h2 t2 -> if h1 <= h2 then S.cons h1 (merge t1 s2) else S.cons h2 (merge s1 t2) | false |
MSort.SeqLemmas.fst | MSort.SeqLemmas.sdrop | val sdrop (#a: _) (i: nat) (s: S.seq a) : Tot (S.seq a) | val sdrop (#a: _) (i: nat) (s: S.seq a) : Tot (S.seq a) | let sdrop #a (i:nat) (s : S.seq a)
: Tot (S.seq a)
= if i <= S.length s
then S.slice s i (S.length s)
else S.empty | {
"file_name": "share/steel/examples/pulse/MSort.SeqLemmas.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 14,
"end_line": 67,
"start_col": 0,
"start_line": 63
} | module MSort.SeqLemmas
open FStar.Ghost
module S = FStar.Seq
assume val sort : Seq.seq int -> Seq.seq int
assume val sorted : Seq.seq int -> bool
assume val sort_is_sorted (s:Seq.seq int) : Lemma (sorted (sort s))
assume val sort_len (s:Seq.seq int)
: Lemma (S.length (sort s) == S.length s)
[SMTPat (S.len... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"sho... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: Prims.nat -> s: FStar.Seq.Base.seq a -> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice",
"Prims.bool",
"FStar.Seq.Base.empty"
] | [] | false | false | false | true | false | let sdrop #a (i: nat) (s: S.seq a) : Tot (S.seq a) =
| if i <= S.length s then S.slice s i (S.length s) else S.empty | false |
MSort.SeqLemmas.fst | MSort.SeqLemmas.stake | val stake (#a: _) (i: nat) (s: S.seq a) : Tot (S.seq a) | val stake (#a: _) (i: nat) (s: S.seq a) : Tot (S.seq a) | let stake #a (i:nat) (s : S.seq a)
: Tot (S.seq a)
= if i <= S.length s
then S.slice s 0 i
else s | {
"file_name": "share/steel/examples/pulse/MSort.SeqLemmas.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 8,
"end_line": 61,
"start_col": 0,
"start_line": 57
} | module MSort.SeqLemmas
open FStar.Ghost
module S = FStar.Seq
assume val sort : Seq.seq int -> Seq.seq int
assume val sorted : Seq.seq int -> bool
assume val sort_is_sorted (s:Seq.seq int) : Lemma (sorted (sort s))
assume val sort_len (s:Seq.seq int)
: Lemma (S.length (sort s) == S.length s)
[SMTPat (S.len... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"sho... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: Prims.nat -> s: FStar.Seq.Base.seq a -> FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice",
"Prims.bool"
] | [] | false | false | false | true | false | let stake #a (i: nat) (s: S.seq a) : Tot (S.seq a) =
| if i <= S.length s then S.slice s 0 i else s | false |
MSort.SeqLemmas.fst | MSort.SeqLemmas.view | val view (#a: _) (s: S.seq a) : seq_view a | val view (#a: _) (s: S.seq a) : seq_view a | let view #a (s : S.seq a) : seq_view a =
if S.length s = 0 then Nil else Cons (S.head s) (S.tail s) | {
"file_name": "share/steel/examples/pulse/MSort.SeqLemmas.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 22,
"start_col": 0,
"start_line": 21
} | module MSort.SeqLemmas
open FStar.Ghost
module S = FStar.Seq
assume val sort : Seq.seq int -> Seq.seq int
assume val sorted : Seq.seq int -> bool
assume val sort_is_sorted (s:Seq.seq int) : Lemma (sorted (sort s))
assume val sort_len (s:Seq.seq int)
: Lemma (S.length (sort s) == S.length s)
[SMTPat (S.len... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"short_module": null
},
{
"abbrev": false,
"full_module": "MSort",
"sho... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a -> MSort.SeqLemmas.seq_view a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MSort.SeqLemmas.Nil",
"Prims.bool",
"MSort.SeqLemmas.Cons",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.tail",
"MSort.SeqLemmas.seq_view"
] | [] | false | false | false | true | false | let view #a (s: S.seq a) : seq_view a =
| if S.length s = 0 then Nil else Cons (S.head s) (S.tail s) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.