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.Seq.Permutation.fst | FStar.Seq.Permutation.split3_index | val split3_index (#a: eqtype) (s0: seq a) (x: a) (s1: seq a) (j: nat)
: Lemma (requires j < Seq.length (Seq.append s0 s1))
(ensures
(let s = Seq.append s0 (Seq.cons x s1) in
let s' = Seq.append s0 s1 in
let n = Seq.length s0 in
if j < n then Seq.index s' j == Seq.index s ... | val split3_index (#a: eqtype) (s0: seq a) (x: a) (s1: seq a) (j: nat)
: Lemma (requires j < Seq.length (Seq.append s0 s1))
(ensures
(let s = Seq.append s0 (Seq.cons x s1) in
let s' = Seq.append s0 s1 in
let n = Seq.length s0 in
if j < n then Seq.index s' j == Seq.index s ... | let split3_index (#a:eqtype) (s0:seq a) (x:a) (s1:seq a) (j:nat)
: Lemma
(requires j < Seq.length (Seq.append s0 s1))
(ensures (
let s = Seq.append s0 (Seq.cons x s1) in
let s' = Seq.append s0 s1 in
let n = Seq.length s0 in
if j < n then Seq.index s' j == Seq.index s j
else Seq.i... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 56,
"start_col": 0,
"start_line": 44
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false,
"full_module":... | {
"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 | s0: FStar.Seq.Base.seq a -> x: a -> s1: FStar.Seq.Base.seq a -> j: Prims.nat
-> FStar.Pervasives.Lemma (requires j < FStar.Seq.Base.length (FStar.Seq.Base.append s0 s1))
(ensures
(let s = FStar.Seq.Base.append s0 (FStar.Seq.Base.cons x s1) in
let s' = FStar.Seq.Base.append s0 s1 in
l... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.op_LessThan",
"Prims.bool",
"Prims.unit",
"FStar.Seq.Base.length",
"FStar.Seq.Base.append",
"Prims.b2t",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.op_Addition",
"FStar.Seq.Base.cons",
"Prims.Nil",
"FStar.Pervas... | [] | false | false | true | false | false | let split3_index (#a: eqtype) (s0: seq a) (x: a) (s1: seq a) (j: nat)
: Lemma (requires j < Seq.length (Seq.append s0 s1))
(ensures
(let s = Seq.append s0 (Seq.cons x s1) in
let s' = Seq.append s0 s1 in
let n = Seq.length s0 in
if j < n then Seq.index s' j == Seq.index s ... | let n = Seq.length (Seq.append s0 s1) in
if j < n then () | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.find | val find (#a: eqtype) (x: a) (s: seq a {count x s > 0})
: Tot
(frags:
(seq a & seq a)
{ let s' = Seq.append (fst frags) (snd frags) in
let n = Seq.length (fst frags) in
s `Seq.equal` (Seq.append (fst frags) (Seq.cons x (snd frags))) })
(decreases (Seq.length s)) | val find (#a: eqtype) (x: a) (s: seq a {count x s > 0})
: Tot
(frags:
(seq a & seq a)
{ let s' = Seq.append (fst frags) (snd frags) in
let n = Seq.length (fst frags) in
s `Seq.equal` (Seq.append (fst frags) (Seq.cons x (snd frags))) })
(decreases (Seq.length s)) | let rec find (#a:eqtype) (x:a) (s:seq a{ count x s > 0 })
: Tot (frags:(seq a & seq a) {
let s' = Seq.append (fst frags) (snd frags) in
let n = Seq.length (fst frags) in
s `Seq.equal` Seq.append (fst frags) (Seq.cons x (snd frags))
}) (decreases (Seq.length s))
= if Seq.head s = x
then Seq... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 74,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> s: FStar.Seq.Base.seq a {FStar.Seq.Properties.count x s > 0}
-> Prims.Tot
(frags:
(FStar.Seq.Base.seq a * FStar.Seq.Base.seq a)
{ let s' =
FStar.Seq.Base.append (FStar.Pervasives.Native.fst frags)
(FStar.Pervasives.Native.snd frags)
in
let n = FS... | Prims.Tot | [
"total",
""
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Properties.count",
"Prims.op_Equality",
"FStar.Seq.Properties.head",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.empty",
"FStar.Seq.Properties.tail",
"Prims.bool",
"FStar.Seq.Base.cons",
"Prims.unit... | [
"recursion"
] | false | false | false | false | false | let rec find (#a: eqtype) (x: a) (s: seq a {count x s > 0})
: Tot
(frags:
(seq a & seq a)
{ let s' = Seq.append (fst frags) (snd frags) in
let n = Seq.length (fst frags) in
s `Seq.equal` (Seq.append (fst frags) (Seq.cons x (snd frags))) })
(decreases (Seq.length... | if Seq.head s = x
then Seq.empty, Seq.tail s
else
(let pfx, sfx = find x (Seq.tail s) in
assert (Seq.equal (Seq.tail s) (Seq.append pfx (Seq.cons x sfx)));
assert (Seq.equal s (Seq.cons (Seq.head s) (Seq.tail s)));
Seq.cons (Seq.head s) pfx, sfx) | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.introduce_is_permutation | val introduce_is_permutation:
#a: Type ->
s0: seq a ->
s1: seq a ->
f: index_fun s0 ->
squash (Seq.length s0 == Seq.length s1) ->
squash (forall x y. x <> y ==> f x <> f y) ->
squash (forall (i: nat{i < Seq.length s0}). Seq.index s0 i == Seq.index s1 (f i))
-> Lemma (ensures is_permutation... | val introduce_is_permutation:
#a: Type ->
s0: seq a ->
s1: seq a ->
f: index_fun s0 ->
squash (Seq.length s0 == Seq.length s1) ->
squash (forall x y. x <> y ==> f x <> f y) ->
squash (forall (i: nat{i < Seq.length s0}). Seq.index s0 i == Seq.index s1 (f i))
-> Lemma (ensures is_permutation... | let introduce_is_permutation (#a:Type) (s0:seq a) (s1:seq a)
(f:index_fun s0)
(_:squash (Seq.length s0 == Seq.length s1))
(_:squash (forall x y. x <> y ==> f x <> f y))
(_:squash (forall (i:nat{i < Seq.le... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 85,
"start_col": 0,
"start_line": 77
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false,
"full_module":... | {
"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 |
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.seq a ->
f: FStar.Seq.Permutation.index_fun s0 ->
_: Prims.squash (FStar.Seq.Base.length s0 == FStar.Seq.Base.length s1) ->
_:
Prims.squash (forall (x: FStar.IntegerIntervals.under (FStar.Seq.Base.length s0))
(y: FStar.IntegerInterval... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Permutation.index_fun",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"FStar.Seq.Permutat... | [] | true | false | true | false | false | let introduce_is_permutation
(#a: Type)
(s0: seq a)
(s1: seq a)
(f: index_fun s0)
(_: squash (Seq.length s0 == Seq.length s1))
(_: squash (forall x y. x <> y ==> f x <> f y))
(_: squash (forall (i: nat{i < Seq.length s0}). Seq.index s0 i == Seq.index s1 (f i)))
: Lemma (ens... | reveal_is_permutation_nopats s0 s1 f | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.witness_exists | val witness_exists (#a:Type) (#opened_invariants:_) (#p:a -> vprop) (_:unit)
: SteelGhostT (erased a) opened_invariants
(h_exists p) (fun x -> p x) | val witness_exists (#a:Type) (#opened_invariants:_) (#p:a -> vprop) (_:unit)
: SteelGhostT (erased a) opened_invariants
(h_exists p) (fun x -> p x) | let witness_exists #a #u #p _ =
SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x))) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 79,
"end_line": 618,
"start_col": 0,
"start_line": 617
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> Steel.Effect.Atomic.SteelGhostT (FStar.Ghost.erased a) | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Memory.witness_h_exists",
"Steel.Effect.Common.hp_of",
"Steel.Memory.slprop",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.h_exists",
"FStar.Ghost.reveal"
] | [] | false | true | false | false | false | let witness_exists #a #u #p _ =
| SteelGhost?.reflect (Steel.Memory.witness_h_exists #u (fun x -> hp_of (p x))) | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.mk_selector_vprop_sel' | val mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p)) | val mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p)) | let mk_selector_vprop_sel'
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p) // unused in the definition, but necessary for the local SMTPats below
: Tot (selector' t (mk_selector_vprop_hp p))
= fun m -> id_elim_exists (hp_of_pointwise p) m | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 47,
"end_line": 882,
"start_col": 0,
"start_line": 877
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Common.selector' t (Steel.Effect.Atomic.mk_selector_vprop_hp p) | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"Steel.Memory.hmem",
"Steel.Effect.Atomic.mk_selector_vprop_hp",
"FStar.Ghost.reveal",
"Steel.Memory.id_elim_exists",
"Steel.Effect.Atomic.hp_of_pointwise",
"Steel.Effect.Common.selector'"
] | [] | false | false | false | false | false | let mk_selector_vprop_sel' (#t: Type) (p: (t -> vprop)) (p_inj: interp_hp_of_injective p)
: Tot (selector' t (mk_selector_vprop_hp p)) =
| fun m -> id_elim_exists (hp_of_pointwise p) m | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_singleton | val foldm_snoc_singleton (#a:_) (#eq:_) (m:CE.cm a eq) (x:a)
: Lemma (eq.eq (foldm_snoc m (Seq.create 1 x)) x) | val foldm_snoc_singleton (#a:_) (#eq:_) (m:CE.cm a eq) (x:a)
: Lemma (eq.eq (foldm_snoc m (Seq.create 1 x)) x) | let foldm_snoc_singleton (#a:_) #eq (m:CE.cm a eq) (x:a)
: Lemma (eq.eq (foldm_snoc m (Seq.create 1 x)) x)
= elim_monoid_laws m | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 274,
"start_col": 0,
"start_line": 272
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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.Algebra.CommMonoid.Equiv.cm a eq -> x: a
-> FStar.Pervasives.Lemma
(ensures EQ?.eq eq (FStar.Seq.Permutation.foldm_snoc m (FStar.Seq.Base.create 1 x)) x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Permutation.elim_monoid_laws",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.create",
"Prims.Nil",
"F... | [] | true | false | true | false | false | let foldm_snoc_singleton (#a: _) #eq (m: CE.cm a eq) (x: a)
: Lemma (eq.eq (foldm_snoc m (Seq.create 1 x)) x) =
| elim_monoid_laws m | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_unit_seq | val foldm_snoc_unit_seq (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s:Seq.seq a)
: Lemma (requires Seq.equal s (Seq.create (Seq.length s) m.unit))
(ensures eq.eq (foldm_snoc m s) m.unit) | val foldm_snoc_unit_seq (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s:Seq.seq a)
: Lemma (requires Seq.equal s (Seq.create (Seq.length s) m.unit))
(ensures eq.eq (foldm_snoc m s) m.unit) | let rec foldm_snoc_unit_seq (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s:Seq.seq a)
: Lemma (requires Seq.equal s (Seq.create (Seq.length s) m.unit))
(ensures eq.eq (foldm_snoc m s) m.unit)
(decreases Seq.length s)
= CE.elim_eq_laws eq;
elim_monoid_laws m;
if Seq.length s = 0
then ()... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 269,
"start_col": 0,
"start_line": 260
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"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 | m: FStar.Algebra.CommMonoid.Equiv.cm a eq -> s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.equal s (FStar.Seq.Base.create (FStar.Seq.Base.length s) (CM?.unit m)))
(ensures EQ?.eq eq (FStar.Seq.Permutation.foldm_snoc m s) (CM?.unit m))
(decreases FStar.Seq.Base.le... | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Permutation.foldm_snoc_unit_seq",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Prope... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_unit_seq (#a: Type) (#eq: CE.equiv a) (m: CE.cm a eq) (s: Seq.seq a)
: Lemma (requires Seq.equal s (Seq.create (Seq.length s) m.unit))
(ensures eq.eq (foldm_snoc m s) m.unit)
(decreases Seq.length s) =
| CE.elim_eq_laws eq;
elim_monoid_laws m;
if Seq.length s = 0
then ()
else
let s_tl, _ = un_snoc s in
foldm_snoc_unit_seq m s_tl | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.elim_eq_laws | val elim_eq_laws (#a: _) (eq: CE.equiv a)
: Lemma
((forall x. {:pattern (x `eq.eq` x)} x `eq.eq` x) /\
(forall x y. {:pattern (x `eq.eq` y)} x `eq.eq` y ==> y `eq.eq` x) /\
(forall x y z. {:pattern eq.eq x y; eq.eq x z} (x `eq.eq` y /\ y `eq.eq` z) ==> x `eq.eq` z)) | val elim_eq_laws (#a: _) (eq: CE.equiv a)
: Lemma
((forall x. {:pattern (x `eq.eq` x)} x `eq.eq` x) /\
(forall x y. {:pattern (x `eq.eq` y)} x `eq.eq` y ==> y `eq.eq` x) /\
(forall x y z. {:pattern eq.eq x y; eq.eq x z} (x `eq.eq` y /\ y `eq.eq` z) ==> x `eq.eq` z)) | let elim_eq_laws #a (eq:CE.equiv a)
: Lemma (
(forall x.{:pattern (x `eq.eq` x)} x `eq.eq` x) /\
(forall x y.{:pattern (x `eq.eq` y)} x `eq.eq` y ==> y `eq.eq` x) /\
(forall x y z.{:pattern eq.eq x y; eq.eq x z} (x `eq.eq` y /\ y `eq.eq` z) ==> x `eq.eq` z)
)
= CE.elim_eq_la... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 500,
"start_col": 0,
"start_line": 494
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"ab... | {
"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 | eq: FStar.Algebra.CommMonoid.Equiv.equiv a
-> FStar.Pervasives.Lemma
(ensures
(forall (x: a). {:pattern EQ?.eq eq x x} EQ?.eq eq x x) /\
(forall (x: a) (y: a). {:pattern EQ?.eq eq x y} EQ?.eq eq x y ==> EQ?.eq eq y x) /\
(forall (x: a) (y: a) (z: a). {:pattern EQ?.eq eq x y; EQ?.eq eq x z}
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.elim_eq_laws",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.l_Forall",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let elim_eq_laws #a (eq: CE.equiv a)
: Lemma
((forall x. {:pattern (x `eq.eq` x)} x `eq.eq` x) /\
(forall x y. {:pattern (x `eq.eq` y)} x `eq.eq` y ==> y `eq.eq` x) /\
(forall x y z. {:pattern eq.eq x y; eq.eq x z} (x `eq.eq` y /\ y `eq.eq` z) ==> x `eq.eq` z)) =
| CE.elim_eq_laws eq | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_sym | val foldm_snoc_sym (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s1 s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2))
(foldm_snoc m (append s2 s1))) | val foldm_snoc_sym (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s1 s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2))
(foldm_snoc m (append s2 s1))) | let foldm_snoc_sym #a #eq (m:CE.cm a eq) (s1 s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2)) (foldm_snoc m (append s2 s1)))
= CE.elim_eq_laws eq;
elim_monoid_laws m;
foldm_snoc_append m s1 s2;
foldm_snoc_append m s2 s1 | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 331,
"start_col": 0,
"start_line": 325
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"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 | m: FStar.Algebra.CommMonoid.Equiv.cm a eq -> s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc m (FStar.Seq.Base.append s1 s2))
(FStar.Seq.Permutation.foldm_snoc m (FStar.Seq.Base.append s2 s1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"FStar.Seq.Permutation.foldm_snoc_append",
"Prims.unit",
"FStar.Seq.Permutation.elim_monoid_laws",
"FStar.Algebra.CommMonoid.Equiv.elim_eq_laws",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMo... | [] | true | false | true | false | false | let foldm_snoc_sym #a #eq (m: CE.cm a eq) (s1: seq a) (s2: seq a)
: Lemma (ensures eq.eq (foldm_snoc m (append s1 s2)) (foldm_snoc m (append s2 s1))) =
| CE.elim_eq_laws eq;
elim_monoid_laws m;
foldm_snoc_append m s1 s2;
foldm_snoc_append m s2 s1 | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.x_yz_to_y_xz | val x_yz_to_y_xz (#a #eq: _) (m: CE.cm a eq) (x y z: a)
: Lemma ((x `m.mult` (y `m.mult` z)) `eq.eq` (y `m.mult` (x `m.mult` z))) | val x_yz_to_y_xz (#a #eq: _) (m: CE.cm a eq) (x y z: a)
: Lemma ((x `m.mult` (y `m.mult` z)) `eq.eq` (y `m.mult` (x `m.mult` z))) | let x_yz_to_y_xz #a #eq (m:CE.cm a eq) (x y z:a)
: Lemma ((x `m.mult` (y `m.mult` z))
`eq.eq`
(y `m.mult` (x `m.mult` z)))
= CE.elim_eq_laws eq;
elim_monoid_laws m;
calc (eq.eq) {
x `m.mult` (y `m.mult` z);
(eq.eq) { m.commutativity x (y `m.mult` z) }
(y `m.mult` z)... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 291,
"start_col": 0,
"start_line": 277
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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.Algebra.CommMonoid.Equiv.cm a eq -> x: a -> y: a -> z: a
-> FStar.Pervasives.Lemma
(ensures EQ?.eq eq (CM?.mult m x (CM?.mult m y z)) (CM?.mult m y (CM?.mult m x z))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Calc.calc_finish",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.cal... | [] | false | false | true | false | false | let x_yz_to_y_xz #a #eq (m: CE.cm a eq) (x: a) (y: a) (z: a)
: Lemma ((x `m.mult` (y `m.mult` z)) `eq.eq` (y `m.mult` (x `m.mult` z))) =
| CE.elim_eq_laws eq;
elim_monoid_laws m;
calc (eq.eq) {
x `m.mult` (y `m.mult` z);
(eq.eq) { m.commutativity x (y `m.mult` z) }
(y `m.mult` z) `m.mult` x;
(eq.eq) { m.associativity y z x }
y `m.mult` (z `m.mult` x);
(eq.eq) { m.congruence y (z `m.mult` x) y (x `m.mult` z) }
y `m.mult` (x `m.mult` z);
} | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.remove_i | val remove_i (#a: _) (s: seq a) (i: nat{i < Seq.length s}) : a & seq a | val remove_i (#a: _) (s: seq a) (i: nat{i < Seq.length s}) : a & seq a | let remove_i #a (s:seq a) (i:nat{i < Seq.length s})
: a & seq a
= let s0, s1 = Seq.split s i in
Seq.head s1, Seq.append s0 (Seq.tail s1) | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 375,
"start_col": 0,
"start_line": 372
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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 -> i: Prims.nat{i < FStar.Seq.Base.length s} -> a * FStar.Seq.Base.seq a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Properties.head",
"FStar.Seq.Base.append",
"FStar.Seq.Properties.tail",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split"
] | [] | false | false | false | false | false | let remove_i #a (s: seq a) (i: nat{i < Seq.length s}) : a & seq a =
| let s0, s1 = Seq.split s i in
Seq.head s1, Seq.append s0 (Seq.tail s1) | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.reveal_star_30 | val reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_b... | val reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_b... | let reveal_star_30 (#opened:inames) (p1 p2 p3:vprop)
: repr unit false opened Unobservable (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1... | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 49,
"end_line": 594,
"start_col": 0,
"start_line": 576
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop -> p3: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.repr Prims.unit
false
opened
Steel.Effect.Common.Unobservable
(Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2) p3)
(fun _ -> Steel.Effect.Common.star (Steel.Ef... | Prims.Tot | [
"total"
] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Memory.slprop",
"Steel.Effect.Common.reveal_mk_rmem",
"Steel.Effect.Common.star",
"Prims.unit",
"Steel.Effect.Common.can_be_split_trans",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.mk_rmem",
"Stee... | [] | false | false | false | false | false | let reveal_star_30 (#opened: inames) (p1 p2 p3: vprop)
: repr unit
false
opened
Unobservable
((p1 `star` p2) `star` p3)
(fun _ -> (p1 `star` p2) `star` p3)
(requires fun _ -> True)
(ensures
fun h0 _ h1 ->
can_be_split ((p1 `star` p2) `star` p3) p1 /\ can_b... | fun frame ->
let m:full_mem = NMSTTotal.get () in
Classical.forall_intro_3 reveal_mk_rmem;
let h0 = mk_rmem ((p1 `star` p2) `star` p3) (core_mem m) in
can_be_split_trans ((p1 `star` p2) `star` p3) (p1 `star` p2) p1;
can_be_split_trans ((p1 `star` p2) `star` p3) (p1 `star` p2) p2;
reveal_mk_rmem ((p1 `star` ... | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.elim_monoid_laws | val elim_monoid_laws (#a #eq: _) (m: CE.cm a eq)
: Lemma
((forall x y. {:pattern m.mult x y} eq.eq (m.mult x y) (m.mult y x)) /\
(forall x y z. {:pattern (m.mult x (m.mult y z))}
eq.eq (m.mult x (m.mult y z)) (m.mult (m.mult x y) z)) /\
(forall x. {:pattern (m.mult x m.unit)} eq.eq (m.mult... | val elim_monoid_laws (#a #eq: _) (m: CE.cm a eq)
: Lemma
((forall x y. {:pattern m.mult x y} eq.eq (m.mult x y) (m.mult y x)) /\
(forall x y z. {:pattern (m.mult x (m.mult y z))}
eq.eq (m.mult x (m.mult y z)) (m.mult (m.mult x y) z)) /\
(forall x. {:pattern (m.mult x m.unit)} eq.eq (m.mult... | let elim_monoid_laws #a #eq (m:CE.cm a eq)
: Lemma (
(forall x y. {:pattern m.mult x y} eq.eq (m.mult x y) (m.mult y x)) /\
(forall x y z.{:pattern (m.mult x (m.mult y z))} eq.eq (m.mult x (m.mult y z)) (m.mult (m.mult x y) z)) /\
(forall x.{:pattern (m.mult x m.unit)} eq.eq (m.mult x m... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 258,
"start_col": 0,
"start_line": 244
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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.Algebra.CommMonoid.Equiv.cm a eq
-> FStar.Pervasives.Lemma
(ensures
(forall (x: a) (y: a). {:pattern CM?.mult m x y} EQ?.eq eq (CM?.mult m x y) (CM?.mult m y x)) /\
(forall (x: a) (y: a) (z: a). {:pattern CM?.mult m x (CM?.mult m y z)}
EQ?.eq eq (CM?.mult m x (CM?.mult m y z)) (CM?.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Classical.Sugar.forall_intro",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Algebra.CommM... | [] | false | false | true | false | false | let elim_monoid_laws #a #eq (m: CE.cm a eq)
: Lemma
((forall x y. {:pattern m.mult x y} eq.eq (m.mult x y) (m.mult y x)) /\
(forall x y z. {:pattern (m.mult x (m.mult y z))}
eq.eq (m.mult x (m.mult y z)) (m.mult (m.mult x y) z)) /\
(forall x. {:pattern (m.mult x m.unit)} eq.eq (m.mult x m.... | introduce forall x y . eq.eq (m.mult x y) (m.mult y x)
with (m.commutativity x y);
introduce forall x y z . eq.eq (m.mult x (m.mult y z)) (m.mult (m.mult x y) z)
with (m.associativity x y z;
eq.symmetry (m.mult (m.mult x y) z) (m.mult x (m.mult y z)));
introduce forall x . eq.eq (m.mult x m.unit) x
with (CE.right_ide... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.subcomp_opaque | val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@... | val subcomp_opaque (a:Type)
(opened:inames)
(o1:eqtype_as_type observability)
(o2:eqtype_as_type observability)
(#framed_f:eqtype_as_type bool)
(#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] req_f:req_t pre_f) (#[@@@... | let subcomp_opaque a opened o1 o2 #framed_f #framed_g #pre_f #post_f #req_f #ens_f #pre_g #post_g #req_g #ens_g #fr #pr #_ #p1 #p2 f =
fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g ... | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 337,
"start_col": 0,
"start_line": 304
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Type ->
opened: Steel.Memory.inames ->
o1: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
o2: FStar.Pervasives.eqtype_as_type Steel.Effect.Common.observability ->
f: Steel.Effect.Atomic.repr a framed_f opened o1 pre_f post_f req_f ens_f
-> Prims.Pure (Steel.Effect.Atomic.... | Prims.Pure | [] | [] | [
"Steel.Memory.inames",
"FStar.Pervasives.eqtype_as_type",
"Steel.Effect.Common.observability",
"Prims.bool",
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.req_t",
"Steel.Effect.Common.ens_t",
"Steel.Effect.Common.vprop",
"Prims.prop",
"Prims.squash",
"Steel.Ef... | [] | false | false | false | false | false | let subcomp_opaque
a
opened
o1
o2
#framed_f
#framed_g
#pre_f
#post_f
#req_f
#ens_f
#pre_g
#post_g
#req_g
#ens_g
#fr
#pr
#_
#p1
#p2
f
=
| fun frame ->
let m0:full_mem = NMSTTotal.get () in
let h0 = mk_rmem pre_g (core_mem m0) in
can_be_split_trans pre_g (pre_f `star` fr) pre_f;
can_be_split_trans pre_g (pre_f `star` fr) fr;
can_be_split_3_interp (hp_of pre_g) (hp_of (pre_f `star` fr)) frame (locks_invariant opened m0) m0;
focus_replace pre_g ... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.mk_selector_vprop_sel | val mk_selector_vprop_sel
(#t: Type0) (p: t -> vprop) (p_inj: interp_hp_of_injective p)
: Tot (selector t (mk_selector_vprop_hp p)) | val mk_selector_vprop_sel
(#t: Type0) (p: t -> vprop) (p_inj: interp_hp_of_injective p)
: Tot (selector t (mk_selector_vprop_hp p)) | let mk_selector_vprop_sel
#t p p_inj
=
let varrayp_sel_depends_only_on
(#t: Type)
(p: t -> vprop)
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
(m1: mem { disjoint m0 m1 })
: Lemma
(
mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_... | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 912,
"start_col": 0,
"start_line": 884
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Common.selector t (Steel.Effect.Atomic.mk_selector_vprop_hp p) | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"Steel.Effect.Atomic.mk_selector_vprop_sel'",
"Steel.Memory.hmem",
"Steel.Effect.Atomic.mk_selector_vprop_hp",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Steel.Memory.core_mem",
"Prims.Cons",
"FStar.Per... | [] | false | false | false | false | false | let mk_selector_vprop_sel #t p p_inj =
| let varrayp_sel_depends_only_on
(#t: Type)
(p: (t -> vprop))
(p_inj: interp_hp_of_injective p)
(m0: Steel.Memory.hmem (mk_selector_vprop_hp p))
(m1: mem{disjoint m0 m1})
: Lemma
(mk_selector_vprop_sel' p p_inj m0 == mk_selector_vprop_sel' p p_inj (Steel.Memory.join m0 m1)
)... | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.cm_associativity | val cm_associativity (#c #eq: _) (cm: CE.cm c eq)
: Lemma
(forall (x: c) (y: c) (z: c). {:pattern ((x `cm.mult` y) `cm.mult` z)}
((x `cm.mult` y) `cm.mult` z) `eq.eq` (x `cm.mult` (y `cm.mult` z))) | val cm_associativity (#c #eq: _) (cm: CE.cm c eq)
: Lemma
(forall (x: c) (y: c) (z: c). {:pattern ((x `cm.mult` y) `cm.mult` z)}
((x `cm.mult` y) `cm.mult` z) `eq.eq` (x `cm.mult` (y `cm.mult` z))) | let cm_associativity #c #eq (cm: CE.cm c eq)
: Lemma (forall (x y z:c). {:pattern (x `cm.mult` y `cm.mult` z)}
(x `cm.mult` y `cm.mult` z) `eq.eq` (x `cm.mult` (y `cm.mult` z)))
= Classical.forall_intro_3 (Classical.move_requires_3 cm.associativity) | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 483,
"start_col": 0,
"start_line": 480
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"ab... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq
-> FStar.Pervasives.Lemma
(ensures
forall (x: c) (y: c) (z: c). {:pattern CM?.mult cm (CM?.mult cm x y) z}
EQ?.eq eq (CM?.mult cm (CM?.mult cm x y) z) (CM?.mult cm x (CM?.mult cm y z))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Classical.forall_intro_3",
"Prims.l_imp",
"Prims.l_True",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Classical.move_requires_3",
"FStar.Alge... | [] | false | false | true | false | false | let cm_associativity #c #eq (cm: CE.cm c eq)
: Lemma
(forall (x: c) (y: c) (z: c). {:pattern ((x `cm.mult` y) `cm.mult` z)}
((x `cm.mult` y) `cm.mult` z) `eq.eq` (x `cm.mult` (y `cm.mult` z))) =
| Classical.forall_intro_3 (Classical.move_requires_3 cm.associativity) | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.eq2_eq | val eq2_eq (#a: _) (eq: CE.equiv a) (x y: a) : Lemma (requires x == y) (ensures x `eq.eq` y) | val eq2_eq (#a: _) (eq: CE.equiv a) (x y: a) : Lemma (requires x == y) (ensures x `eq.eq` y) | let eq2_eq #a (eq:CE.equiv a) (x y:a)
: Lemma (requires x == y)
(ensures x `eq.eq` y)
= eq.reflexivity x | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 418,
"start_col": 0,
"start_line": 415
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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 | eq: FStar.Algebra.CommMonoid.Equiv.equiv a -> x: a -> y: a
-> FStar.Pervasives.Lemma (requires x == y) (ensures EQ?.eq eq x y) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"Prims.unit",
"Prims.eq2",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let eq2_eq #a (eq: CE.equiv a) (x: a) (y: a) : Lemma (requires x == y) (ensures x `eq.eq` y) =
| eq.reflexivity x | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.shift_perm | val shift_perm:
#a: _ ->
s0: seq a ->
s1: seq a ->
squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0) ->
p: seqperm s0 s1
-> Pure (seqperm (fst (Seq.un_snoc s0)) (snd (remove_i s1 (p (Seq.length s0 - 1)))))
(requires True)
(ensures
fun _ ->
let n = Seq.lengt... | val shift_perm:
#a: _ ->
s0: seq a ->
s1: seq a ->
squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0) ->
p: seqperm s0 s1
-> Pure (seqperm (fst (Seq.un_snoc s0)) (snd (remove_i s1 (p (Seq.length s0 - 1)))))
(requires True)
(ensures
fun _ ->
let n = Seq.lengt... | let shift_perm #a
(s0 s1:seq a)
(_:squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0))
(p:seqperm s0 s1)
: Pure (seqperm (fst (Seq.un_snoc s0))
(snd (remove_i s1 (p (Seq.length s0 - 1)))))
(requires True)
(ensures fun _ -> let ... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 407,
"start_col": 0,
"start_line": 396
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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 |
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.seq a ->
_:
Prims.squash (FStar.Seq.Base.length s0 == FStar.Seq.Base.length s1 /\
FStar.Seq.Base.length s0 > 0) ->
p: FStar.Seq.Permutation.seqperm s0 s1
-> Prims.Pure
(FStar.Seq.Permutation.seqperm (FStar.Pervasives.Native.fst (FStar... | Prims.Pure | [] | [] | [
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Permutation.seqperm",
"FStar.Seq.Permutation.shift_perm'",
"Prims.unit",
"FStar.Seq.Permutation.reveal_is_permutation",
"FStar.Pervasives.Na... | [] | false | false | false | false | false | let shift_perm
#a
(s0: seq a)
(s1: seq a)
(_: squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0))
(p: seqperm s0 s1)
: Pure (seqperm (fst (Seq.un_snoc s0)) (snd (remove_i s1 (p (Seq.length s0 - 1)))))
(requires True)
(ensures
fun _ ->
let n = Seq... | reveal_is_permutation s0 s1 p;
shift_perm' s0 s1 () p | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc3 | val foldm_snoc3 (#a #eq: _) (m: CE.cm a eq) (s1: seq a) (x: a) (s2: seq a)
: Lemma
(eq.eq (foldm_snoc m (Seq.append s1 (Seq.cons x s2)))
(m.mult x (foldm_snoc m (Seq.append s1 s2)))) | val foldm_snoc3 (#a #eq: _) (m: CE.cm a eq) (s1: seq a) (x: a) (s2: seq a)
: Lemma
(eq.eq (foldm_snoc m (Seq.append s1 (Seq.cons x s2)))
(m.mult x (foldm_snoc m (Seq.append s1 s2)))) | let foldm_snoc3 #a #eq (m:CE.cm a eq) (s1:seq a) (x:a) (s2:seq a)
: Lemma (eq.eq (foldm_snoc m (Seq.append s1 (Seq.cons x s2)))
(m.mult x (foldm_snoc m (Seq.append s1 s2))))
= CE.elim_eq_laws eq;
elim_monoid_laws m;
calc (eq.eq)
{
foldm_snoc m (Seq.append s1 (Seq.cons x s2));
... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 368,
"start_col": 0,
"start_line": 334
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"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.Algebra.CommMonoid.Equiv.cm a eq ->
s1: FStar.Seq.Base.seq a ->
x: a ->
s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc m (FStar.Seq.Base.append s1 (FStar.Seq.Base.cons x s2)))
(CM?.mult m x (FStar.Seq.Permutat... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"FStar.Calc.calc_finish",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.append",
"FStar.Seq.Base.cons",
"FStar.Algebra.CommMonoid.Equiv.__pr... | [] | false | false | true | false | false | let foldm_snoc3 #a #eq (m: CE.cm a eq) (s1: seq a) (x: a) (s2: seq a)
: Lemma
(eq.eq (foldm_snoc m (Seq.append s1 (Seq.cons x s2)))
(m.mult x (foldm_snoc m (Seq.append s1 s2)))) =
| CE.elim_eq_laws eq;
elim_monoid_laws m;
calc (eq.eq) {
foldm_snoc m (Seq.append s1 (Seq.cons x s2));
(eq.eq) { foldm_snoc_append m s1 (Seq.cons x s2) }
m.mult (foldm_snoc m s1) (foldm_snoc m (Seq.cons x s2));
(eq.eq) { (foldm_snoc_append m (Seq.create 1 x) s2;
m.congruence (foldm_snoc m s1)
(foldm_sno... | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.cm_commutativity | val cm_commutativity (#c #eq: _) (cm: CE.cm c eq)
: Lemma
(forall (x: c) (y: c). {:pattern (x `cm.mult` y)} (x `cm.mult` y) `eq.eq` (y `cm.mult` x)) | val cm_commutativity (#c #eq: _) (cm: CE.cm c eq)
: Lemma
(forall (x: c) (y: c). {:pattern (x `cm.mult` y)} (x `cm.mult` y) `eq.eq` (y `cm.mult` x)) | let cm_commutativity #c #eq (cm: CE.cm c eq)
: Lemma (forall (x y:c). {:pattern (x `cm.mult` y)}
(x `cm.mult` y) `eq.eq` (y `cm.mult` x))
= Classical.forall_intro_2 (Classical.move_requires_2 cm.commutativity) | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 488,
"start_col": 0,
"start_line": 485
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"ab... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq
-> FStar.Pervasives.Lemma
(ensures
forall (x: c) (y: c). {:pattern CM?.mult cm x y} EQ?.eq eq (CM?.mult cm x y) (CM?.mult cm y x)
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"Prims.l_True",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Classical.move_requires_2",
"FStar.Alge... | [] | false | false | true | false | false | let cm_commutativity #c #eq (cm: CE.cm c eq)
: Lemma
(forall (x: c) (y: c). {:pattern (x `cm.mult` y)} (x `cm.mult` y) `eq.eq` (y `cm.mult` x)) =
| Classical.forall_intro_2 (Classical.move_requires_2 cm.commutativity) | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.seqperm_len | val seqperm_len (#a: _) (s0 s1: seq a) (p: seqperm s0 s1)
: Lemma (ensures Seq.length s0 == Seq.length s1) | val seqperm_len (#a: _) (s0 s1: seq a) (p: seqperm s0 s1)
: Lemma (ensures Seq.length s0 == Seq.length s1) | let seqperm_len #a (s0 s1:seq a)
(p:seqperm s0 s1)
: Lemma
(ensures Seq.length s0 == Seq.length s1)
= reveal_is_permutation s0 s1 p | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 413,
"start_col": 0,
"start_line": 409
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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 | s0: FStar.Seq.Base.seq a -> s1: FStar.Seq.Base.seq a -> p: FStar.Seq.Permutation.seqperm s0 s1
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.length s0 == FStar.Seq.Base.length s1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Permutation.seqperm",
"FStar.Seq.Permutation.reveal_is_permutation",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let seqperm_len #a (s0: seq a) (s1: seq a) (p: seqperm s0 s1)
: Lemma (ensures Seq.length s0 == Seq.length s1) =
| reveal_is_permutation s0 s1 p | false |
Pulse.PP.fst | Pulse.PP.printable_option | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_option: a: Type -> printable a -> printable (option a) | [@@ FStar.Tactics.Typeclasses.tcinstance]
val printable_option: a: Type -> printable a -> printable (option a) | instance printable_option (a:Type) (_ : printable a) : printable (option a) = {
pp = (function None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v);
} | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 1,
"end_line": 67,
"start_col": 0,
"start_line": 64
} | (*
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.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.... | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"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 -> _: Pulse.PP.printable a -> Pulse.PP.printable (FStar.Pervasives.Native.option a) | Prims.Tot | [
"total"
] | [] | [
"Pulse.PP.printable",
"Pulse.PP.Mkprintable",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Pprint.doc_of_string",
"FStar.Stubs.Pprint.document",
"FStar.Stubs.Pprint.op_Hat_Slash_Hat",
"Pulse.PP.pp"
] | [] | false | false | false | true | false | [@@ FStar.Tactics.Typeclasses.tcinstance]
let printable_option (a: Type) (_: printable a) : printable (option a) =
| {
pp
=
(function
| None -> doc_of_string "None"
| Some v -> doc_of_string "Some" ^/^ pp v)
} | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.aux_shuffle_lemma | val aux_shuffle_lemma (#c #eq: _) (cm: CE.cm c eq) (s1 s2 l1 l2: c)
: Lemma
(((s1 `cm.mult` s2) `cm.mult` (l1 `cm.mult` l2))
`eq.eq`
((s1 `cm.mult` l1) `cm.mult` (s2 `cm.mult` l2))) | val aux_shuffle_lemma (#c #eq: _) (cm: CE.cm c eq) (s1 s2 l1 l2: c)
: Lemma
(((s1 `cm.mult` s2) `cm.mult` (l1 `cm.mult` l2))
`eq.eq`
((s1 `cm.mult` l1) `cm.mult` (s2 `cm.mult` l2))) | let aux_shuffle_lemma #c #eq (cm: CE.cm c eq)
(s1 s2 l1 l2: c)
: Lemma (((s1 `cm.mult` s2) `cm.mult` (l1 `cm.mult` l2)) `eq.eq`
((s1 `cm.mult` l1) `cm.mult` (s2 `cm.mult` l2)))
= elim_eq_laws eq;
cm_commutativity cm;
cm_associativity cm;
let (+) = cm.mult ... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 535,
"start_col": 0,
"start_line": 524
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"ab... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> s1: c -> s2: c -> l1: c -> l2: c
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(CM?.mult cm (CM?.mult cm s1 s2) (CM?.mult cm l1 l2))
(CM?.mult cm (CM?.mult cm s1 l1) (CM?.mult cm s2 l2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.cm_associativity",
"FStar.Seq.Permutation.cm_commutativity",
"FStar.... | [] | true | false | true | false | false | let aux_shuffle_lemma #c #eq (cm: CE.cm c eq) (s1: c) (s2: c) (l1: c) (l2: c)
: Lemma
(((s1 `cm.mult` s2) `cm.mult` (l1 `cm.mult` l2))
`eq.eq`
((s1 `cm.mult` l1) `cm.mult` (s2 `cm.mult` l2))) =
| elim_eq_laws eq;
cm_commutativity cm;
cm_associativity cm;
let ( + ) = cm.mult in
cm.congruence (s1 + s2) l1 (s2 + s1) l1;
cm.congruence ((s1 + s2) + l1) l2 ((s2 + s1) + l1) l2;
cm.congruence ((s2 + s1) + l1) l2 (s2 + (s1 + l1)) l2;
cm.congruence (s2 + (s1 + l1)) l2 ((s1 + l1) + s2) l2 | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.shift_perm' | val shift_perm':
#a: _ ->
s0: seq a ->
s1: seq a ->
squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0) ->
p: seqperm s0 s1
-> Tot (seqperm (fst (Seq.un_snoc s0)) (snd (remove_i s1 (p (Seq.length s0 - 1))))) | val shift_perm':
#a: _ ->
s0: seq a ->
s1: seq a ->
squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0) ->
p: seqperm s0 s1
-> Tot (seqperm (fst (Seq.un_snoc s0)) (snd (remove_i s1 (p (Seq.length s0 - 1))))) | let shift_perm' #a
(s0 s1:seq a)
(_:squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0))
(p:seqperm s0 s1)
: Tot (seqperm (fst (Seq.un_snoc s0))
(snd (remove_i s1 (p (Seq.length s0 - 1)))))
= reveal_is_permutation s0 s1 p;
let s0', last = Se... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 6,
"end_line": 393,
"start_col": 0,
"start_line": 378
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev"... | {
"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 |
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.seq a ->
_:
Prims.squash (FStar.Seq.Base.length s0 == FStar.Seq.Base.length s1 /\
FStar.Seq.Base.length s0 > 0) ->
p: FStar.Seq.Permutation.seqperm s0 s1
-> FStar.Seq.Permutation.seqperm (FStar.Pervasives.Native.fst (FStar.Seq.Properties.... | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Permutation.seqperm",
"Prims.unit",
"FStar.Seq.Permutation.reveal_is_permutation_nopats",
"FStar.Pervasives.Native.fst",
"FStar.Seq.Properti... | [] | false | false | false | false | false | let shift_perm'
#a
(s0: seq a)
(s1: seq a)
(_: squash (Seq.length s0 == Seq.length s1 /\ Seq.length s0 > 0))
(p: seqperm s0 s1)
: Tot (seqperm (fst (Seq.un_snoc s0)) (snd (remove_i s1 (p (Seq.length s0 - 1))))) =
| reveal_is_permutation s0 s1 p;
let s0', last = Seq.un_snoc s0 in
let n = Seq.length s0' in
let p' (i: nat{i < n}) : j: nat{j < n} = if p i < p n then p i else p i - 1 in
let _, s1' = remove_i s1 (p n) in
reveal_is_permutation_nopats s0' s1' p';
p' | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_split | val foldm_snoc_split (#c:_) (#eq:_)
(cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1 expr2: (ifrom_ito n0 nk) -> c)
: Lemma (ensures (foldm_snoc cm (init (closed_interval_size n0 nk) (init_func_from_expr (func_sum cm expr1 exp... | val foldm_snoc_split (#c:_) (#eq:_)
(cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1 expr2: (ifrom_ito n0 nk) -> c)
: Lemma (ensures (foldm_snoc cm (init (closed_interval_size n0 nk) (init_func_from_expr (func_sum cm expr1 exp... | let foldm_snoc_split #c #eq (cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1 expr2: (ifrom_ito n0 nk) -> c)
= foldm_snoc_split' cm n0 nk expr1 expr2 | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 636,
"start_col": 0,
"start_line": 632
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
n0: Prims.int ->
nk: FStar.IntegerIntervals.not_less_than n0 ->
expr1: (_: FStar.IntegerIntervals.ifrom_ito n0 nk -> c) ->
expr2: (_: FStar.IntegerIntervals.ifrom_ito n0 nk -> c)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Se... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.int",
"FStar.IntegerIntervals.not_less_than",
"FStar.IntegerIntervals.ifrom_ito",
"FStar.Seq.Permutation.foldm_snoc_split'",
"Prims.unit"
] | [] | true | false | true | false | false | let foldm_snoc_split
#c
#eq
(cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1: ((ifrom_ito n0 nk) -> c))
(expr2: ((ifrom_ito n0 nk) -> c))
=
| foldm_snoc_split' cm n0 nk expr1 expr2 | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_append | val foldm_snoc_append (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s1 s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2))
(m.mult (foldm_snoc m s1) (foldm_snoc m s2))) | val foldm_snoc_append (#a:Type) (#eq:CE.equiv a) (m:CE.cm a eq) (s1 s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2))
(m.mult (foldm_snoc m s1) (foldm_snoc m s2))) | let rec foldm_snoc_append #a #eq (m:CE.cm a eq) (s1 s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2))
(m.mult (foldm_snoc m s1) (foldm_snoc m s2)))
(decreases (Seq.length s2))
= CE.elim_eq_laws eq;
elim_monoid_laws m;
if Seq.length s2 = 0
then assert (Seq.append ... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 322,
"start_col": 0,
"start_line": 294
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.Algebra.CommMonoid.Equiv.cm a eq -> s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc m (FStar.Seq.Base.append s1 s2))
(CM?.mult m
(FStar.Seq.Permutation.foldm_snoc m s1)
... | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"Prims.bool",
"FStar.Calc.calc_finish",
"FStar.Algebra.CommMonoid.Equi... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_append #a #eq (m: CE.cm a eq) (s1: seq a) (s2: seq a)
: Lemma
(ensures eq.eq (foldm_snoc m (append s1 s2)) (m.mult (foldm_snoc m s1) (foldm_snoc m s2)))
(decreases (Seq.length s2)) =
| CE.elim_eq_laws eq;
elim_monoid_laws m;
if Seq.length s2 = 0
then assert ((Seq.append s1 s2) `Seq.equal` s1)
else
(let s2', last = Seq.un_snoc s2 in
calc (eq.eq) {
foldm_snoc m (append s1 s2);
(eq.eq) { assert (Seq.equal (append s1 s2) (Seq.snoc (append s1 s2') last)) }
foldm_snoc m (Seq.snoc (a... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.intro_exists | val intro_exists (#a:Type) (#opened_invariants:_) (x:a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | val intro_exists (#a:Type) (#opened_invariants:_) (x:a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | let intro_exists #a #opened x p =
rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 95,
"end_line": 611,
"start_col": 0,
"start_line": 610
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> p: (_: a -> Steel.Effect.Common.vprop) -> Steel.Effect.Atomic.SteelGhostT Prims.unit | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Atomic.h_exists",
"Steel.Memory.mem",
"Steel.Memory.intro_h_exists",
"Steel.Effect.Atomic.h_exists_sl'",
"Prims.unit"
] | [] | false | true | false | false | false | let intro_exists #a #opened x p =
| rewrite_slprop (p x) (h_exists p) (fun m -> Steel.Memory.intro_h_exists x (h_exists_sl' p) m) | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_equality | val foldm_snoc_equality (#c:_) (#eq:_) (add: CE.cm c eq) (s t: seq c)
: Lemma (requires length s == length t /\ eq_of_seq eq s t)
(ensures foldm_snoc add s `eq.eq` foldm_snoc add t) | val foldm_snoc_equality (#c:_) (#eq:_) (add: CE.cm c eq) (s t: seq c)
: Lemma (requires length s == length t /\ eq_of_seq eq s t)
(ensures foldm_snoc add s `eq.eq` foldm_snoc add t) | let rec foldm_snoc_equality #c #eq (add: CE.cm c eq) (s t: seq c)
: Lemma (requires length s == length t /\ eq_of_seq eq s t)
(ensures foldm_snoc add s `eq.eq` foldm_snoc add t)
(decreases length s) =
if length s = 0 then (
assert_norm (foldm_snoc add s == add.unit);
assert_norm (foldm_... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 656,
"start_col": 0,
"start_line": 640
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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 | add: FStar.Algebra.CommMonoid.Equiv.cm c eq -> s: FStar.Seq.Base.seq c -> t: FStar.Seq.Base.seq c
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length s == FStar.Seq.Base.length t /\ FStar.Seq.Equiv.eq_of_seq eq s t)
(ensures
EQ?.eq eq (FStar.Seq.Permutation.foldm_snoc add s) (FStar.S... | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.unit",
"FSta... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_equality #c #eq (add: CE.cm c eq) (s: seq c) (t: seq c)
: Lemma (requires length s == length t /\ eq_of_seq eq s t)
(ensures (foldm_snoc add s) `eq.eq` (foldm_snoc add t))
(decreases length s) =
| if length s = 0
then
(assert_norm (foldm_snoc add s == add.unit);
assert_norm (foldm_snoc add t == add.unit);
eq.reflexivity add.unit)
else
(let sliat, slast = un_snoc s in
let tliat, tlast = un_snoc t in
eq_of_seq_unsnoc eq (length s) s t;
foldm_snoc_equality add sliat tliat;
add.congruence... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.as_atomic_o_action | val as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x)) | val as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x)) | let as_atomic_o_action
(#a:Type u#a)
(#opened_invariants:inames)
(#fp:slprop)
(#fp': a -> slprop)
(o:observability)
(f:action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop... | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 31,
"end_line": 663,
"start_col": 0,
"start_line": 655
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Steel.Effect.Common.observability -> f: Steel.Memory.action_except a opened_invariants fp fp'
-> Steel.Effect.Atomic.SteelAtomicBaseT a | Steel.Effect.Atomic.SteelAtomicBaseT | [] | [] | [
"Steel.Memory.inames",
"Steel.Memory.slprop",
"Steel.Effect.Common.observability",
"Steel.Memory.action_except",
"Steel.Effect.Common.to_vprop",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let as_atomic_o_action
(#a: Type u#a)
(#opened_invariants: inames)
(#fp: slprop)
(#fp': (a -> slprop))
(o: observability)
(f: action_except a opened_invariants fp fp')
: SteelAtomicBaseT a opened_invariants o (to_vprop fp) (fun x -> to_vprop (fp' x)) =
| SteelAtomicBaseT?.reflect f | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.fold_decomposition_aux | val fold_decomposition_aux
(#c #eq: _)
(cm: CE.cm c eq)
(n0: int)
(nk: int{nk = n0})
(expr1 expr2: ((ifrom_ito n0 nk) -> c))
: Lemma
((foldm_snoc cm
(init (closed_interval_size n0 nk) (init_func_from_expr (func_sum cm expr1 expr2) n0 nk)))
`eq.eq`
(cm.mult (fo... | val fold_decomposition_aux
(#c #eq: _)
(cm: CE.cm c eq)
(n0: int)
(nk: int{nk = n0})
(expr1 expr2: ((ifrom_ito n0 nk) -> c))
: Lemma
((foldm_snoc cm
(init (closed_interval_size n0 nk) (init_func_from_expr (func_sum cm expr1 expr2) n0 nk)))
`eq.eq`
(cm.mult (fo... | let fold_decomposition_aux #c #eq (cm: CE.cm c eq)
(n0: int)
(nk: int{nk=n0})
(expr1 expr2: (ifrom_ito n0 nk) -> c)
: Lemma (foldm_snoc cm (init (closed_interval_size n0 nk)
(init_func_from_expr (func_sum c... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 522,
"start_col": 0,
"start_line": 502
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"ab... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
n0: Prims.int ->
nk: Prims.int{nk = n0} ->
expr1: (_: FStar.IntegerIntervals.ifrom_ito n0 nk -> c) ->
expr2: (_: FStar.IntegerIntervals.ifrom_ito n0 nk -> c)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_s... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.int",
"Prims.b2t",
"Prims.op_Equality",
"FStar.IntegerIntervals.ifrom_ito",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.unit",
"FStar.Seq.Permutation.fo... | [] | false | false | true | false | false | let fold_decomposition_aux
#c
#eq
(cm: CE.cm c eq)
(n0: int)
(nk: int{nk = n0})
(expr1: ((ifrom_ito n0 nk) -> c))
(expr2: ((ifrom_ito n0 nk) -> c))
: Lemma
((foldm_snoc cm
(init (closed_interval_size n0 nk) (init_func_from_expr (func_sum cm expr1 expr2) n0 nk)... | elim_eq_laws eq;
let sum_of_funcs (i: under (closed_interval_size n0 nk)) =
(expr1 (n0 + i)) `cm.mult` (expr2 (n0 + i))
in
lemma_eq_elim (init (closed_interval_size n0 nk) sum_of_funcs)
(create 1 ((expr1 n0) `cm.mult` (expr2 n0)));
foldm_snoc_singleton cm ((expr1 n0) `cm.mult` (expr2 n0));
let ts = (init (closed_in... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.intro_exists_erased | val intro_exists_erased (#a:Type) (#opened_invariants:_) (x:Ghost.erased a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | val intro_exists_erased (#a:Type) (#opened_invariants:_) (x:Ghost.erased a) (p:a -> vprop)
: SteelGhostT unit opened_invariants (p x) (fun _ -> h_exists p) | let intro_exists_erased #a #opened x p =
rewrite_slprop (p x) (h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 78,
"end_line": 615,
"start_col": 0,
"start_line": 613
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.Ghost.erased a -> p: (_: a -> Steel.Effect.Common.vprop)
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.reveal",
"Steel.Effect.Atomic.h_exists",
"Steel.Memory.mem",
"Steel.Memory.intro_h_exists",
"Steel.Effect.Atomic.h_exists_sl'",
"Prims.unit"
] | [] | false | true | false | false | false | let intro_exists_erased #a #opened x p =
| rewrite_slprop (p x)
(h_exists p)
(fun m -> Steel.Memory.intro_h_exists (Ghost.reveal x) (h_exists_sl' p) m) | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_perm | val foldm_snoc_perm (#a:_) (#eq:_)
(m:CE.cm a eq)
(s0:seq a)
(s1:seq a)
(p:seqperm s0 s1)
: Lemma
(ensures eq.eq (foldm_snoc m s0) (foldm_snoc m s1)) | val foldm_snoc_perm (#a:_) (#eq:_)
(m:CE.cm a eq)
(s0:seq a)
(s1:seq a)
(p:seqperm s0 s1)
: Lemma
(ensures eq.eq (foldm_snoc m s0) (foldm_snoc m s1)) | let rec foldm_snoc_perm #a #eq m s0 s1 p
: Lemma
(ensures eq.eq (foldm_snoc m s0) (foldm_snoc m s1))
(decreases (Seq.length s0))
= //for getting calc chain to compose
CE.elim_eq_laws eq;
seqperm_len s0 s1 p;
if Seq.length s0 = 0 then (
assert (Seq.equal s0 s1);
eq2_eq eq (foldm_snoc ... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 467,
"start_col": 0,
"start_line": 422
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: FStar.Algebra.CommMonoid.Equiv.cm a eq ->
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.seq a ->
p: FStar.Seq.Permutation.seqperm s0 s1
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq (FStar.Seq.Permutation.foldm_snoc m s0) (FStar.Seq.Permutation.foldm_snoc m s1))
(decreases FSta... | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"FStar.Seq.Permutation.seqperm",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Permutation.eq2_eq",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.unit",
"Prims._assert",
"FSt... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_perm #a #eq m s0 s1 p
: Lemma (ensures eq.eq (foldm_snoc m s0) (foldm_snoc m s1)) (decreases (Seq.length s0)) =
| CE.elim_eq_laws eq;
seqperm_len s0 s1 p;
if Seq.length s0 = 0
then
(assert (Seq.equal s0 s1);
eq2_eq eq (foldm_snoc m s0) (foldm_snoc m s1))
else
(let n0 = Seq.length s0 - 1 in
let prefix, last = Seq.un_snoc s0 in
let prefix', suffix' = Seq.split s1 (p n0) in
let last', suffix' = Seq.head suffix', S... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.exists_cong | val exists_cong (#a:_) (#u:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: SteelGhostT unit u
(h_exists p)
(fun _ -> h_exists q) | val exists_cong (#a:_) (#u:_) (p:a -> vprop) (q:a -> vprop {forall x. equiv (p x) (q x) })
: SteelGhostT unit u
(h_exists p)
(fun _ -> h_exists q) | let exists_cong p q =
rewrite_slprop (h_exists p) (h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 23,
"end_line": 631,
"start_col": 0,
"start_line": 627
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: (_: a -> Steel.Effect.Common.vprop) ->
q: (_: a -> Steel.Effect.Common.vprop){forall (x: a). Steel.Effect.Common.equiv (p x) (q x)}
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Prims.l_Forall",
"Steel.Effect.Common.equiv",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Atomic.h_exists",
"Steel.Memory.mem",
"Steel.Effect.Atomic.exists_equiv",
"Prims.unit",
"Steel.Effect.Common.reveal_equiv"
] | [] | false | true | false | false | false | let exists_cong p q =
| rewrite_slprop (h_exists p)
(h_exists q)
(fun m ->
reveal_equiv (h_exists p) (h_exists q);
exists_equiv p q) | false |
Pulse.PP.fst | Pulse.PP.separate_map | val separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document | val separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document | let rec separate_map (sep: document) (f : 'a -> Tac document) (l : list 'a) : Tac document =
match l with
| [] -> empty
| [x] -> f x
| x::xs -> f x ^^ sep ^/^ separate_map sep f xs | {
"file_name": "lib/steel/pulse/Pulse.PP.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 49,
"end_line": 75,
"start_col": 0,
"start_line": 71
} | (*
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.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.Base.fsti.checked",
"Pulse.Show.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Typeclasses.fsti.... | [
{
"abbrev": false,
"full_module": "Pulse.Show",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Printer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Base",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"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 |
sep: FStar.Stubs.Pprint.document ->
f: (_: 'a -> FStar.Tactics.Effect.Tac FStar.Stubs.Pprint.document) ->
l: Prims.list 'a
-> FStar.Tactics.Effect.Tac FStar.Stubs.Pprint.document | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Stubs.Pprint.document",
"Prims.list",
"FStar.Stubs.Pprint.empty",
"FStar.Stubs.Pprint.op_Hat_Hat",
"FStar.Stubs.Pprint.op_Hat_Slash_Hat",
"Pulse.PP.separate_map"
] | [
"recursion"
] | false | true | false | false | false | let rec separate_map (sep: document) (f: ('a -> Tac document)) (l: list 'a) : Tac document =
| match l with
| [] -> empty
| [x] -> f x
| x :: xs -> f x ^^ sep ^/^ separate_map sep f xs | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_split_seq | val foldm_snoc_split_seq (#c:_) (#eq:_) (add: CE.cm c eq)
(s: seq c) (t: seq c{length s == length t})
(sum_seq: seq c{length sum_seq == length s})
(proof: (i: under (length s))
-> Lemma ((index s i `add.mult` i... | val foldm_snoc_split_seq (#c:_) (#eq:_) (add: CE.cm c eq)
(s: seq c) (t: seq c{length s == length t})
(sum_seq: seq c{length sum_seq == length s})
(proof: (i: under (length s))
-> Lemma ((index s i `add.mult` i... | let foldm_snoc_split_seq #c #eq (add: CE.cm c eq)
(s: seq c) (t: seq c{length s == length t})
(sum_seq: seq c{length sum_seq == length s})
(proof: (i: under (length s)) -> Lemma ((index s i `add.mult` index t i)
`eq.eq` (index sum_se... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 696,
"start_col": 0,
"start_line": 658
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
s: FStar.Seq.Base.seq c ->
t: FStar.Seq.Base.seq c {FStar.Seq.Base.length s == FStar.Seq.Base.length t} ->
sum_seq: FStar.Seq.Base.seq c {FStar.Seq.Base.length sum_seq == FStar.Seq.Base.length s} ->
proof:
(i: FStar.IntegerIntervals.under (FStar.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.IntegerIntervals.under",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Alge... | [] | false | false | true | false | false | let foldm_snoc_split_seq
#c
#eq
(add: CE.cm c eq)
(s: seq c)
(t: seq c {length s == length t})
(sum_seq: seq c {length sum_seq == length s})
(proof:
(i: under (length s)
-> Lemma (((index s i) `add.mult` (index t i)) `eq.eq` (index sum_seq i))))
: Le... | if length s = 0
then add.identity add.unit
else
let n = length s in
let index_1 (i: under n) = index s i in
let index_2 (i: under n) = index t i in
let nk = (n - 1) in
assert (n == closed_interval_size 0 nk);
let index_sum = func_sum add index_1 index_2 in
let expr1 = init_func_from_expr #c #0 #(n - 1) in... | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.mk_to_p256_prime_comm_monoid | val mk_to_p256_prime_comm_monoid:BE.to_comm_monoid U64 4ul 0ul | val mk_to_p256_prime_comm_monoid:BE.to_comm_monoid U64 4ul 0ul | let mk_to_p256_prime_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.felem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
} | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 44,
"start_col": 0,
"start_line": 38
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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.Impl.Exponentiation.Definitions.to_comm_monoid Lib.IntTypes.U64
(4ul <: FStar.UInt32.t)
(0ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.Mkto_comm_monoid",
"Lib.IntTypes.U64",
"FStar.UInt32.uint_to_t",
"Spec.P256.PointOps.felem",
"Hacl.Spec.P256.Finv.nat_mod_comm_monoid",
"Hacl.Impl.P256.Finv.linv_ctx",
"Hacl.Impl.P256.Finv.linv",
"Hacl.Impl.P256.Finv.refl"
] | [] | false | false | false | false | false | let mk_to_p256_prime_comm_monoid:BE.to_comm_monoid U64 4ul 0ul =
| {
BE.a_spec = S.felem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl
} | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.mk_p256_prime_concrete_ops | val mk_p256_prime_concrete_ops:BE.concrete_ops U64 4ul 0ul | val mk_p256_prime_concrete_ops:BE.concrete_ops U64 4ul 0ul | let mk_p256_prime_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_p256_prime_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
} | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 68,
"start_col": 0,
"start_line": 63
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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.Impl.Exponentiation.Definitions.concrete_ops Lib.IntTypes.U64
(4ul <: FStar.UInt32.t)
(0ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.Mkconcrete_ops",
"Lib.IntTypes.U64",
"FStar.UInt32.uint_to_t",
"FStar.Ghost.hide",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Hacl.Impl.P256.Finv.mk_to_p256_prime_comm_monoid",
"Hacl.Impl.P256.Finv.one_mod",
"Hacl.Impl.P256.Finv.mul_mod",
"Hacl.Impl... | [] | false | false | false | false | false | let mk_p256_prime_concrete_ops:BE.concrete_ops U64 4ul 0ul =
| { BE.to = mk_to_p256_prime_comm_monoid; BE.lone = one_mod; BE.lmul = mul_mod; BE.lsqr = sqr_mod } | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.linv_ctx | val linv_ctx (a: LSeq.lseq uint64 0) : Type0 | val linv_ctx (a: LSeq.lseq uint64 0) : Type0 | let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 26,
"start_col": 0,
"start_line": 26
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.l_True"
] | [] | false | false | false | false | true | let linv_ctx (a: LSeq.lseq uint64 0) : Type0 =
| True | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.fsquare_times_in_place | val fsquare_times_in_place (out:felem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ as_nat h out < S.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_nat h1 out < S.prime /\
fmont_as_nat h1 out == SI.fsquare_times (fmont_as_nat h0 out) (v b)) | val fsquare_times_in_place (out:felem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ as_nat h out < S.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_nat h1 out < S.prime /\
fmont_as_nat h1 out == SI.fsquare_times (fmont_as_nat h0 out) (v b)) | let fsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (fmont_as_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_p256_prime_concrete_ops (null uint64) out b | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 78,
"end_line": 82,
"start_col": 0,
"start_line": 79
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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 | out: Hacl.Impl.P256.Bignum.felem -> b: Lib.IntTypes.size_t -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Lib.IntTypes.size_t",
"Hacl.Impl.Exponentiation.lexp_pow2_in_place",
"Lib.IntTypes.U64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Finv.mk_p256_prime_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.unit",
"Spec.Exponentiation.ex... | [] | false | true | false | false | false | let fsquare_times_in_place out b =
| let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (fmont_as_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_p256_prime_concrete_ops (null uint64) out b | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.linv | val linv (a: LSeq.lseq uint64 4) : Type0 | val linv (a: LSeq.lseq uint64 4) : Type0 | let linv (a:LSeq.lseq uint64 4) : Type0 =
BD.bn_v a < S.prime | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 30,
"start_col": 0,
"start_line": 29
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 4 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Spec.P256.PointOps.prime"
] | [] | false | false | false | false | true | let linv (a: LSeq.lseq uint64 4) : Type0 =
| BD.bn_v a < S.prime | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.fsquare_times | val fsquare_times (out a:felem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_nat h1 out < S.prime /\
fmont_as_nat h1 out == SI.fsquare_times (fmont_as_nat h0 a) (v b)) | val fsquare_times (out a:felem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_nat h1 out < S.prime /\
fmont_as_nat h1 out == SI.fsquare_times (fmont_as_nat h0 a) (v b)) | let fsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (fmont_as_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_p256_prime_concrete_ops (null uint64) a b out | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 97,
"start_col": 0,
"start_line": 94
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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 | out: Hacl.Impl.P256.Bignum.felem -> a: Hacl.Impl.P256.Bignum.felem -> b: Lib.IntTypes.size_t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Lib.IntTypes.size_t",
"Hacl.Impl.Exponentiation.lexp_pow2",
"Lib.IntTypes.U64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Finv.mk_p256_prime_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.unit",
"Spec.Exponentiation.exp_pow2_le... | [] | false | true | false | false | false | let fsquare_times out a b =
| let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (fmont_as_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_p256_prime_concrete_ops (null uint64) a b out | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.one_mod | val one_mod : BE.lone_st U64 4ul 0ul mk_to_p256_prime_comm_monoid | val one_mod : BE.lone_st U64 4ul 0ul mk_to_p256_prime_comm_monoid | let one_mod ctx one = make_fone one | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 49,
"start_col": 0,
"start_line": 49
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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.Impl.Exponentiation.Definitions.lone_st Lib.IntTypes.U64
4ul
0ul
Hacl.Impl.P256.Finv.mk_to_p256_prime_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Field.make_fone",
"Prims.unit"
] | [] | false | false | false | false | false | let one_mod ctx one =
| make_fone one | false |
LowParseWriters.fsti | LowParseWriters.memory_invariant_includes | val memory_invariant_includes : ol: LowParseWriters.memory_invariant -> ne: LowParseWriters.memory_invariant -> Prims.logical | let memory_invariant_includes (ol ne: memory_invariant) =
B.modifies ol.lwrite ol.h0 ne.h0 /\
HS.get_tip ol.h0 `HS.includes` HS.get_tip ne.h0 /\
ol.lwrite `B.loc_includes` ne.lwrite | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 45,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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 | ol: LowParseWriters.memory_invariant -> ne: LowParseWriters.memory_invariant -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.memory_invariant",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"FStar.Ghost.reveal",
"LowStar.Monotonic.Buffer.loc",
"LowParseWriters.__proj__Mkmemory_invariant__item__lwrite",
"FStar.Monotonic.HyperStack.mem",
"LowParseWriters.__proj__Mkmemory_invariant__item__h0",
"Prims.b... | [] | false | false | false | true | true | let memory_invariant_includes (ol ne: memory_invariant) =
| B.modifies ol.lwrite ol.h0 ne.h0 /\ (HS.get_tip ol.h0) `HS.includes` (HS.get_tip ne.h0) /\
ol.lwrite `B.loc_includes` ne.lwrite | false | |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.new_invariant | val new_invariant (#opened_invariants:inames) (p:vprop)
: SteelAtomicUT (inv p) opened_invariants p (fun _ -> emp) | val new_invariant (#opened_invariants:inames) (p:vprop)
: SteelAtomicUT (inv p) opened_invariants p (fun _ -> emp) | let new_invariant #uses p = let i = fresh_invariant #uses p [] in return i | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 74,
"end_line": 639,
"start_col": 0,
"start_line": 639
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.Effect.Common.vprop -> Steel.Effect.Atomic.SteelAtomicUT (Steel.Effect.Common.inv p) | Steel.Effect.Atomic.SteelAtomicUT | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.return",
"Steel.Effect.Common.inv",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Steel.Effect.Common.req",
"Steel.Effect.Common.rm",
"Steel.Effect.Atomic.fresh_inv",
"Prims.Nil",
"Steel.Memory.pre_inv",
"Steel.... | [] | false | true | false | false | false | let new_invariant #uses p =
| let i = fresh_invariant #uses p [] in
return i | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_of_equal_inits | val foldm_snoc_of_equal_inits (#c:_) (#eq:_) (#m: pos) (cm: CE.cm c eq)
(f: (under m) -> c) (g: (under m) -> c)
: Lemma (requires (forall (i: under m). f i `eq.eq` g i))
(ensures foldm_snoc cm (init m f) `eq.eq` foldm_snoc cm (init m g)) | val foldm_snoc_of_equal_inits (#c:_) (#eq:_) (#m: pos) (cm: CE.cm c eq)
(f: (under m) -> c) (g: (under m) -> c)
: Lemma (requires (forall (i: under m). f i `eq.eq` g i))
(ensures foldm_snoc cm (init m f) `eq.eq` foldm_snoc cm (init m g)) | let rec foldm_snoc_of_equal_inits #c #eq #m (cm: CE.cm c eq)
(f: (under m) -> c)
(g: (under m) -> c)
: Lemma (requires (forall (i: under m). f i `eq.eq` g i))
(ensures foldm_snoc cm (init m f) `eq.eq`
foldm_snoc cm (i... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 725,
"start_col": 0,
"start_line": 698
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
f: (_: FStar.IntegerIntervals.under m -> c) ->
g: (_: FStar.IntegerIntervals.under m -> c)
-> FStar.Pervasives.Lemma
(requires forall (i: FStar.IntegerIntervals.under m). EQ?.eq eq (f i) (g i))
(ensures
EQ?.eq eq
(FStar.Seq.Permu... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"Prims.op_Equality",
"Prims.int",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.unit",
"FStar.... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_of_equal_inits
#c
#eq
#m
(cm: CE.cm c eq)
(f: ((under m) -> c))
(g: ((under m) -> c))
: Lemma (requires (forall (i: under m). (f i) `eq.eq` (g i)))
(ensures (foldm_snoc cm (init m f)) `eq.eq` (foldm_snoc cm (init m g))) =
| if m = 0
then
(assert_norm (foldm_snoc cm (init m f) == cm.unit);
assert_norm (foldm_snoc cm (init m g) == cm.unit);
eq.reflexivity cm.unit)
else
if m = 1
then
(foldm_snoc_singleton cm (f 0);
foldm_snoc_singleton cm (g 0);
eq.transitivity (foldm_snoc cm (init m f)) (f 0) (g 0);
eq.sy... | false |
LowParseWriters.fsti | LowParseWriters.read_return | val read_return (a: Type) (x: a) (inv: memory_invariant)
: Tot (read_repr a True (fun res -> res == x) (fun _ -> False) inv) | val read_return (a: Type) (x: a) (inv: memory_invariant)
: Tot (read_repr a True (fun res -> res == x) (fun _ -> False) inv) | let read_return
(a:Type) (x:a) (inv: memory_invariant)
: Tot (read_repr a True (fun res -> res == x) (fun _ -> False) inv)
= ReadRepr _ (read_return_impl a x inv) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 160,
"start_col": 0,
"start_line": 157
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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 -> inv: LowParseWriters.memory_invariant
-> LowParseWriters.read_repr a Prims.l_True (fun res -> res == x) (fun _ -> Prims.l_False) inv | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.memory_invariant",
"LowParseWriters.ReadRepr",
"Prims.l_True",
"Prims.eq2",
"Prims.unit",
"Prims.l_False",
"LowParseWriters.read_return_spec",
"LowParseWriters.read_return_impl",
"LowParseWriters.read_repr"
] | [] | false | false | false | false | false | let read_return (a: Type) (x: a) (inv: memory_invariant)
: Tot (read_repr a True (fun res -> res == x) (fun _ -> False) inv) =
| ReadRepr _ (read_return_impl a x inv) | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.sqr_mod | val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_p256_prime_comm_monoid | val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_p256_prime_comm_monoid | let sqr_mod ctx x xx = fsqr xx x | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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.Impl.Exponentiation.Definitions.lsqr_st Lib.IntTypes.U64
4ul
0ul
Hacl.Impl.P256.Finv.mk_to_p256_prime_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Field.fsqr",
"Prims.unit"
] | [] | false | false | false | false | false | let sqr_mod ctx x xx =
| fsqr xx x | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.finv_256 | val finv_256 (x256 x2 x30 a:felem) : Stack unit
(requires fun h ->
live h a /\ live h x30 /\ live h x2 /\ live h x256 /\
disjoint a x30 /\ disjoint a x2 /\ disjoint a x256 /\
disjoint x30 x2 /\ disjoint x30 x256 /\ disjoint x2 x256 /\
as_nat h a < S.prime /\ as_nat h x30 < S.prime /\ as_nat h x2 < S.p... | val finv_256 (x256 x2 x30 a:felem) : Stack unit
(requires fun h ->
live h a /\ live h x30 /\ live h x2 /\ live h x256 /\
disjoint a x30 /\ disjoint a x2 /\ disjoint a x256 /\
disjoint x30 x2 /\ disjoint x30 x256 /\ disjoint x2 x256 /\
as_nat h a < S.prime /\ as_nat h x30 < S.prime /\ as_nat h x2 < S.p... | let finv_256 x256 x2 x30 a =
let h0 = ST.get () in
fsquare_times x256 x30 2ul;
fmul x256 x256 x2;
let h1 = ST.get () in
assert (fmont_as_nat h1 x256 == // x32
S.fmul (SI.fsquare_times (fmont_as_nat h0 x30) 2) (fmont_as_nat h0 x2));
fsquare_times x2 x256 32ul;
fmul x2 x2 a;
let h2 = ST.get () in
a... | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 214,
"start_col": 0,
"start_line": 178
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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 |
x256: Hacl.Impl.P256.Bignum.felem ->
x2: Hacl.Impl.P256.Bignum.felem ->
x30: Hacl.Impl.P256.Bignum.felem ->
a: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.felem",
"Hacl.Impl.P256.Field.fmont_as_nat",
"Spec.P256.PointOps.fmul",
"Hacl.Spec.P256.Finv.fsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.P256.Field.fmul",
... | [] | false | true | false | false | false | let finv_256 x256 x2 x30 a =
| let h0 = ST.get () in
fsquare_times x256 x30 2ul;
fmul x256 x256 x2;
let h1 = ST.get () in
assert (fmont_as_nat h1 x256 ==
S.fmul (SI.fsquare_times (fmont_as_nat h0 x30) 2) (fmont_as_nat h0 x2));
fsquare_times x2 x256 32ul;
fmul x2 x2 a;
let h2 = ST.get () in
assert (fmont_as_nat h2 x2 ==
S.fmul (SI.fsquare_tim... | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.mul_mod | val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_p256_prime_comm_monoid | val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_p256_prime_comm_monoid | let mul_mod ctx x y xy = fmul xy x y | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 54,
"start_col": 0,
"start_line": 54
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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.Impl.Exponentiation.Definitions.lmul_st Lib.IntTypes.U64
4ul
0ul
Hacl.Impl.P256.Finv.mk_to_p256_prime_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Field.fmul",
"Prims.unit"
] | [] | false | false | false | false | false | let mul_mod ctx x y xy =
| fmul xy x y | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.elim_pure | val elim_pure (#uses:_) (p:prop)
: SteelGhost unit uses (pure p) (fun _ -> emp)
(requires fun _ -> True) (ensures fun _ _ _ -> p) | val elim_pure (#uses:_) (p:prop)
: SteelGhost unit uses (pure p) (fun _ -> emp)
(requires fun _ -> True) (ensures fun _ _ _ -> p) | let elim_pure #uses p =
let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ()) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 64,
"end_line": 606,
"start_col": 0,
"start_line": 604
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Prims.prop -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Prims.prop",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Common.to_vprop",
"Steel.Memory.emp",
"Steel.Effect.Common.emp",
"Steel.Memory.mem",
"Steel.Effect.Common.reveal_emp",
"Prims.unit",
"Steel.Effect.Atomic.elim_pure_aux"
] | [] | false | true | false | false | false | let elim_pure #uses p =
| let _ = elim_pure_aux p in
rewrite_slprop (to_vprop Mem.emp) emp (fun _ -> reveal_emp ()) | false |
LowParseWriters.fsti | LowParseWriters.read_subcomp_cond | val read_subcomp_cond
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(l l': memory_invariant)
: GTot Type0 | val read_subcomp_cond
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(l l': memory_invariant)
: GTot Type0 | let read_subcomp_cond
(a:Type)
(pre: pure_pre) (post: pure_post' a pre) (post_err: pure_post_err pre)
(pre': pure_pre) (post': pure_post' a pre') (post_err': pure_post_err pre')
(l: memory_invariant)
(l' : memory_invariant)
: GTot Type0
= l `memory_invariant_includes` l' /\
read_subcomp_spec_cond a pre post... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 259,
"start_col": 0,
"start_line": 251
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
pre': Prims.pure_pre ->
post': LowParseWriters.pure_post' a pre' ->
post_err': LowParseWriters.pure_post_err pre' ->
l: LowParseWriters.memory_invariant ->
l': ... | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.memory_invariant",
"Prims.l_and",
"LowParseWriters.memory_invariant_includes",
"LowParseWriters.read_subcomp_spec_cond"
] | [] | false | false | false | false | true | let read_subcomp_cond
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(l l': memory_invariant)
: GTot Type0 =
| l `memory_invariant_includes` l' /\ read_subcomp_spec_cond a pre post post_err pre' post' post_err' | false |
LowParseWriters.fsti | LowParseWriters.read_subcomp_spec_cond | val read_subcomp_spec_cond
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
: GTot Type0 | val read_subcomp_spec_cond
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
: GTot Type0 | let read_subcomp_spec_cond
(a:Type)
(pre: pure_pre) (post: pure_post' a pre) (post_err: pure_post_err pre)
(pre': pure_pre) (post': pure_post' a pre') (post_err': pure_post_err pre')
: GTot Type0
= (pre' ==> pre) /\
(forall x . (pre' /\ post x) ==> post' x) /\
((pre' /\ post_err ()) ==> post_err' ()) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 248,
"start_col": 0,
"start_line": 241
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
pre': Prims.pure_pre ->
post': LowParseWriters.pure_post' a pre' ->
post_err': LowParseWriters.pure_post_err pre'
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"Prims.l_and",
"Prims.l_imp",
"Prims.l_Forall"
] | [] | false | false | false | false | true | let read_subcomp_spec_cond
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
: GTot Type0 =
| (pre' ==> pre) /\ (forall x. (pre' /\ post x) ==> post' x) /\
((pre' /\ post_err ()) ==> post_err' ()) | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.reveal_star_3 | val reveal_star_3 (#opened:inames) (p1 p2 p3:vprop)
: SteelGhost unit opened (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 =... | val reveal_star_3 (#opened:inames) (p1 p2 p3:vprop)
: SteelGhost unit opened (p1 `star` p2 `star` p3) (fun _ -> p1 `star` p2 `star` p3)
(requires fun _ -> True)
(ensures fun h0 _ h1 ->
can_be_split (p1 `star` p2 `star` p3) p1 /\
can_be_split (p1 `star` p2 `star` p3) p2 /\
h0 p1 == h1 p1 /\ h0 p2 =... | let reveal_star_3 p1 p2 p3 = SteelGhost?.reflect (reveal_star_30 p1 p2 p3) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 74,
"end_line": 596,
"start_col": 0,
"start_line": 596
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop -> p3: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.reveal_star_30",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_o... | [] | false | true | false | false | false | let reveal_star_3 p1 p2 p3 =
| SteelGhost?.reflect (reveal_star_30 p1 p2 p3) | false |
LowParseWriters.fsti | LowParseWriters.destr_read_repr_impl | val destr_read_repr_impl
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: Tot (read_repr_impl a pre post post_err l (destr_read_repr_spec a pre post post_err l r)) | val destr_read_repr_impl
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: Tot (read_repr_impl a pre post post_err l (destr_read_repr_spec a pre post post_err l r)) | let destr_read_repr_impl
(a:Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: unit -> ERead a pre post post_err l)
: Tot (read_repr_impl a pre post post_err l (destr_read_repr_spec a pre post post_err l r))
= ReadRepr?.impl (reify (r ())) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 386,
"start_col": 0,
"start_line": 378
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
l: LowParseWriters.memory_invariant ->
$r: (_: Prims.unit -> LowParseWriters.ERead a)
-> LowParseWriters.read_repr_impl a
pre
post
post_err
l
... | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.memory_invariant",
"Prims.unit",
"LowParseWriters.__proj__ReadRepr__item__impl",
"LowParseWriters.read_repr_impl",
"LowParseWriters.destr_read_repr_spec"
] | [] | false | false | false | false | false | let destr_read_repr_impl
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: Tot (read_repr_impl a pre post post_err l (destr_read_repr_spec a pre post post_err l r)) =
| ReadRepr?.impl (reify (r ())) | false |
LowParseWriters.fsti | LowParseWriters.is_uvar | val is_uvar (t: term) : Tac bool | val is_uvar (t: term) : Tac bool | let is_uvar (t:term) : Tac bool = match inspect t with
| Tv_Uvar _ _ -> true
| Tv_App _ _ ->
let hd, args = collect_app t in
Tv_Uvar? (inspect hd)
| _ -> false | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 414,
"start_col": 0,
"start_line": 409
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: FStar.Tactics.NamedView.term -> FStar.Tactics.Effect.Tac Prims.bool | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.term",
"Prims.nat",
"FStar.Stubs.Reflection.Types.ctx_uvar_and_subst",
"Prims.bool",
"FStar.Stubs.Reflection.V2.Data.argv",
"Prims.list",
"FStar.Tactics.NamedView.uu___is_Tv_Uvar",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Tactics.NamedView.inspect",
"FStar.Pervasi... | [] | false | true | false | false | false | let is_uvar (t: term) : Tac bool =
| match inspect t with
| Tv_Uvar _ _ -> true
| Tv_App _ _ ->
let hd, args = collect_app t in
Tv_Uvar? (inspect hd)
| _ -> false | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.lemma_proj_g_pow2_192_eval | val lemma_proj_g_pow2_192_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_128 64 == proj_g_pow2_192) | val lemma_proj_g_pow2_192_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_128 64 == proj_g_pow2_192) | let lemma_proj_g_pow2_192_eval () =
SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_128 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64);
let rX : S.felem ... | {
"file_name": "code/ecdsap256/Hacl.P256.PrecompTable.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 102,
"start_col": 0,
"start_line": 95
} | module Hacl.P256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module SPT256 = Hacl.Spec.Pr... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hac... | [
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Spec.Exponentiation.exp_pow2 Spec.P256.mk_p256_concrete_ops
Hacl.P256.PrecompTable.proj_g_pow2_128
64 ==
Hacl.P256.PrecompTable.proj_g_pow2_192) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.l_and",
"Prims.eq2",
"Spec.P256.PointOps.felem",
"FStar.Pervasives.normalize_term_spec",
"Spec.P256.PointOps.proj_point",
"Hacl.Spec.PrecompBaseTable256.exp_pow2_rec",
"Spec.P256.mk_p256_concrete_ops",
"Hacl.P256.PrecompTable.proj... | [] | false | false | true | false | false | let lemma_proj_g_pow2_192_eval () =
| SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_128 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_128 64);
let rX:S.felem = 0xc762a9c8ae1b2f7434ff8da70fe105e0d4f1885949... | false |
LowParseWriters.fsti | LowParseWriters.destr_read_repr_spec | val destr_read_repr_spec
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: Tot (read_repr_spec a pre post post_err) | val destr_read_repr_spec
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: Tot (read_repr_spec a pre post post_err) | let destr_read_repr_spec
(a:Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: unit -> ERead a pre post post_err l)
: Tot (read_repr_spec a pre post post_err)
= ReadRepr?.spec (reify (r ())) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 375,
"start_col": 0,
"start_line": 367
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
l: LowParseWriters.memory_invariant ->
$r: (_: Prims.unit -> LowParseWriters.ERead a)
-> LowParseWriters.read_repr_spec a pre post post_err | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.memory_invariant",
"Prims.unit",
"LowParseWriters.__proj__ReadRepr__item__spec",
"LowParseWriters.read_repr_spec"
] | [] | false | false | false | false | false | let destr_read_repr_spec
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: Tot (read_repr_spec a pre post post_err) =
| ReadRepr?.spec (reify (r ())) | false |
LowParseWriters.fsti | LowParseWriters.lift_pure_read | val lift_pure_read (a: Type) (wp: pure_wp a) (l: memory_invariant) (f_pure: (unit -> PURE a wp))
: Tot
(read_repr a (wp (fun _ -> True)) (fun x -> ~(wp (fun x' -> ~(x == x')))) (fun _ -> False) l) | val lift_pure_read (a: Type) (wp: pure_wp a) (l: memory_invariant) (f_pure: (unit -> PURE a wp))
: Tot
(read_repr a (wp (fun _ -> True)) (fun x -> ~(wp (fun x' -> ~(x == x')))) (fun _ -> False) l) | let lift_pure_read (a:Type) (wp:pure_wp a)
(l: memory_invariant)
(f_pure:unit -> PURE a wp)
: Tot (read_repr a
(wp (fun _ -> True)) // (lift_pure_read_pre a wp)
(fun x -> ~ (wp (fun x' -> ~ (x == x')))) // (lift_pure_read_post a wp)
(fun _ -> False) // (lift_pure_read_post_err a wp))
l
)
= elim_pu... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 363,
"start_col": 0,
"start_line": 353
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: Prims.pure_wp a ->
l: LowParseWriters.memory_invariant ->
f_pure: (_: Prims.unit -> Prims.PURE a)
-> LowParseWriters.read_repr a
(wp (fun _ -> Prims.l_True))
(fun x -> ~(wp (fun x' -> ~(x == x'))))
(fun _ -> Prims.l_False)
l | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_wp",
"LowParseWriters.memory_invariant",
"Prims.unit",
"LowParseWriters.ReadRepr",
"Prims.l_True",
"Prims.l_not",
"Prims.eq2",
"Prims.l_False",
"LowParseWriters.lift_pure_read_spec",
"LowParseWriters.lift_pure_read_impl",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall",
"Lo... | [] | false | false | false | false | false | let lift_pure_read (a: Type) (wp: pure_wp a) (l: memory_invariant) (f_pure: (unit -> PURE a wp))
: Tot
(read_repr a (wp (fun _ -> True)) (fun x -> ~(wp (fun x' -> ~(x == x')))) (fun _ -> False) l) =
| elim_pure_wp_monotonicity_forall ();
ReadRepr _ (lift_pure_read_impl a wp f_pure l) | false |
LowParseWriters.fsti | LowParseWriters.rewrite_eqs_from_context_non_sq | val rewrite_eqs_from_context_non_sq: Prims.unit -> Tac unit | val rewrite_eqs_from_context_non_sq: Prims.unit -> Tac unit | let rewrite_eqs_from_context_non_sq () : Tac unit =
rewrite_all_context_equalities (List.Tot.map binding_to_binder (cur_vars ())) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 81,
"end_line": 464,
"start_col": 0,
"start_line": 463
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"LowParseWriters.rewrite_all_context_equalities",
"FStar.Tactics.NamedView.binders",
"FStar.List.Tot.Base.map",
"FStar.Tactics.NamedView.binding",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.binding_to_binder",
"Prims.list",
"FStar.Tactics.V2.Derived.cur_vars"
] | [] | false | true | false | false | false | let rewrite_eqs_from_context_non_sq () : Tac unit =
| rewrite_all_context_equalities (List.Tot.map binding_to_binder (cur_vars ())) | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.refl | val refl (a: LSeq.lseq uint64 4 {linv a}) : GTot S.felem | val refl (a: LSeq.lseq uint64 4 {linv a}) : GTot S.felem | let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.felem =
SM.from_mont (BD.bn_v a) | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 4 {Hacl.Impl.P256.Finv.linv a}
-> Prims.GTot Spec.P256.PointOps.felem | Prims.GTot | [
"sometrivial"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Impl.P256.Finv.linv",
"Hacl.Spec.P256.Montgomery.from_mont",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Spec.P256.PointOps.felem"
] | [] | false | false | false | false | false | let refl (a: LSeq.lseq uint64 4 {linv a}) : GTot S.felem =
| SM.from_mont (BD.bn_v a) | false |
LowParseWriters.fsti | LowParseWriters.is_eq | val is_eq (t: term) : Tac (option (term & term)) | val is_eq (t: term) : Tac (option (term & term)) | let is_eq (t:term) : Tac (option (term & term)) =
match term_as_formula t with
| Comp (Eq _) l r -> Some (l, r)
| _ -> None | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 419,
"start_col": 0,
"start_line": 416
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(FStar.Pervasives.Native.option (FStar.Tactics.NamedView.term * FStar.Tactics.NamedView.term)) | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.term",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.Formula.formula",
"FStar.Pervasives.Native.None",
"FStar.Reflection.V2.Form... | [] | false | true | false | false | false | let is_eq (t: term) : Tac (option (term & term)) =
| match term_as_formula t with
| Comp (Eq _) l r -> Some (l, r)
| _ -> None | false |
LowParseWriters.fsti | LowParseWriters.rewrite_eqs_from_context | val rewrite_eqs_from_context: Prims.unit -> Tac unit | val rewrite_eqs_from_context: Prims.unit -> Tac unit | let rewrite_eqs_from_context () : Tac unit =
rewrite_eqs_from_context ();
rewrite_eqs_from_context_non_sq () | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 468,
"start_col": 0,
"start_line": 466
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"LowParseWriters.rewrite_eqs_from_context_non_sq",
"FStar.Tactics.V2.Derived.rewrite_eqs_from_context"
] | [] | false | true | false | false | false | let rewrite_eqs_from_context () : Tac unit =
| rewrite_eqs_from_context ();
rewrite_eqs_from_context_non_sq () | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.elim_vrewrite | val elim_vrewrite (#opened:inames)
(v: vprop)
(#t: Type)
(f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v)) | val elim_vrewrite (#opened:inames)
(v: vprop)
(#t: Type)
(f: (normal (t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v)) | let elim_vrewrite
v #t f
=
change_slprop_rel
(vrewrite v f)
v
(fun y x -> y == f x)
(fun m -> vrewrite_sel_eq v f m) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 862,
"start_col": 0,
"start_line": 855
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
v: Steel.Effect.Common.vprop ->
f: (_: Steel.Effect.Common.normal (Steel.Effect.Common.t_of v) -> Prims.GTot t)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Effect.Atomic.change_slprop_rel",
"Steel.Effect.Common.vrewrite",
"Prims.eq2",
"Prims.prop",
"Steel.Memory.mem",
"Steel.Effect.Common.vrewrite_sel_eq",
"Prims.unit"
] | [] | false | true | false | false | false | let elim_vrewrite v #t f =
| change_slprop_rel (vrewrite v f) v (fun y x -> y == f x) (fun m -> vrewrite_sel_eq v f m) | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.permutation_from_equal_counts | val permutation_from_equal_counts
(#a:eqtype)
(s0:seq a) (s1:seq a{(forall x. count x s0 == count x s1)})
: Tot (seqperm s0 s1) | val permutation_from_equal_counts
(#a:eqtype)
(s0:seq a) (s1:seq a{(forall x. count x s0 == count x s1)})
: Tot (seqperm s0 s1) | let rec permutation_from_equal_counts (#a:eqtype) (s0:seq a) (s1:seq a{(forall x. count x s0 == count x s1)})
: Tot (seqperm s0 s1)
(decreases (Seq.length s0))
= if Seq.length s0 = 0
then (
let f : index_fun s0 = fun i -> i in
reveal_is_permutation_pats s0 s1 f;
equal_counts_empty s0 s... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 238,
"start_col": 0,
"start_line": 127
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"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 |
s0: FStar.Seq.Base.seq a ->
s1:
FStar.Seq.Base.seq a
{forall (x: a). FStar.Seq.Properties.count x s0 == FStar.Seq.Properties.count x s1}
-> Prims.Tot (FStar.Seq.Permutation.seqperm s0 s1) | Prims.Tot | [
"",
"total"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.l_Forall",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Properties.count",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"FStar.Seq.Permutation.equal_counts_empty",
"FStar.Seq.Permutation.reveal_is_permutation_pats",
"FStar.Seq.... | [
"recursion"
] | false | false | false | false | false | let rec permutation_from_equal_counts
(#a: eqtype)
(s0: seq a)
(s1: seq a {(forall x. count x s0 == count x s1)})
: Tot (seqperm s0 s1) (decreases (Seq.length s0)) =
| if Seq.length s0 = 0
then
(let f:index_fun s0 = fun i -> i in
reveal_is_permutation_pats s0 s1 f;
equal_counts_empty s0 s1;
f)
else
(count_head s0;
assert (count (Seq.head s0) s0 > 0);
let pfx, sfx = find (Seq.head s0) s1 in
introduce forall x . count x (Seq.tail s0) == count x (Seq.append p... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.mk_selector_vprop_intro | val mk_selector_vprop_intro
(#opened: _) (#t: Type0) (#x: t)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost unit opened
(p x)
(fun _ -> mk_selector_vprop p p_inj)
(fun _ -> True)
(fun _ _ h' -> h' (mk_selector_vprop p p_inj) == x) | val mk_selector_vprop_intro
(#opened: _) (#t: Type0) (#x: t)
(p: t -> vprop) (p_inj: interp_hp_of_injective p)
: SteelGhost unit opened
(p x)
(fun _ -> mk_selector_vprop p p_inj)
(fun _ -> True)
(fun _ _ h' -> h' (mk_selector_vprop p p_inj) == x) | let mk_selector_vprop_intro
#_ #_ #x p p_inj
= change_slprop_rel
(p _)
(mk_selector_vprop p p_inj)
(fun _ x' -> x == x')
(fun m ->
intro_h_exists x (hp_of_pointwise p) m;
let x' = mk_selector_vprop_sel' p p_inj m in
p_inj x x' m
) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 924,
"start_col": 0,
"start_line": 914
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: t -> Steel.Effect.Common.vprop) -> p_inj: Steel.Effect.Atomic.interp_hp_of_injective p
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.interp_hp_of_injective",
"Steel.Effect.Atomic.change_slprop_rel",
"Steel.Effect.Atomic.mk_selector_vprop",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.eq2",
"Prims.prop",
"Steel.Memory.mem",
"Steel.Effe... | [] | false | true | false | false | false | let mk_selector_vprop_intro #_ #_ #x p p_inj =
| change_slprop_rel (p _)
(mk_selector_vprop p p_inj)
(fun _ x' -> x == x')
(fun m ->
intro_h_exists x (hp_of_pointwise p) m;
let x' = mk_selector_vprop_sel' p p_inj m in
p_inj x x' m) | false |
LowParseWriters.fsti | LowParseWriters.tac | val tac: Prims.unit -> Tac unit | val tac: Prims.unit -> Tac unit | let rec tac () : Tac unit =
if List.length (goals ()) = 0
then ()
else if pick_next (FStar.List.length (goals ()))
then begin
or_else (fun _ -> rewrite_eqs_from_context (); norm []; trefl ()) (fun _ -> assumption ());
tac ()
end
else begin
rewrite_eqs_from_context ();
norm [];
trefl ();
... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 484,
"start_col": 0,
"start_line": 471
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"Prims.bool",
"LowParseWriters.tac",
"FStar.Tactics.V2.Derived.or_else",
"FStar.Tactics.V2.Derived.trefl",
"FStar.Stubs.Tactics.V2.Builtins.norm",
"Prims.Nil",
"FStar.Pervasives.norm_step",
"LowParseWriters.rewrite_eqs_from_context",
"FStar.Tactics.V2.Derived.assumption",
"LowParse... | [
"recursion"
] | false | true | false | false | false | let rec tac () : Tac unit =
| if List.length (goals ()) = 0
then ()
else
if pick_next (FStar.List.length (goals ()))
then
(or_else (fun _ ->
rewrite_eqs_from_context ();
norm [];
trefl ())
(fun _ -> assumption ());
tac ())
else
(rewrite_eqs_from_context ();
norm [];
trefl (... | false |
FStar.Seq.Permutation.fst | FStar.Seq.Permutation.foldm_snoc_split' | val foldm_snoc_split'
(#c #eq: _)
(cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1 expr2: ((ifrom_ito n0 nk) -> c))
: Tot
(squash ((foldm_snoc cm
(init (closed_interval_size n0 nk)
(init_func_from_expr (func_sum cm expr1 expr2) n0 nk)))... | val foldm_snoc_split'
(#c #eq: _)
(cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1 expr2: ((ifrom_ito n0 nk) -> c))
: Tot
(squash ((foldm_snoc cm
(init (closed_interval_size n0 nk)
(init_func_from_expr (func_sum cm expr1 expr2) n0 nk)))... | let rec foldm_snoc_split' #c #eq (cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1 expr2: (ifrom_ito n0 nk) -> c)
: Tot (squash (foldm_snoc cm (init (closed_interval_size n0 nk) (init_func_from_expr (func_sum cm expr1 expr2) n0 nk... | {
"file_name": "ulib/FStar.Seq.Permutation.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 628,
"start_col": 0,
"start_line": 557
} | (*
Copyright 2021-2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checke... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"ab... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
n0: Prims.int ->
nk: FStar.IntegerIntervals.not_less_than n0 ->
expr1: (_: FStar.IntegerIntervals.ifrom_ito n0 nk -> c) ->
expr2: (_: FStar.IntegerIntervals.ifrom_ito n0 nk -> c)
-> Prims.Tot
(Prims.squash (EQ?.eq eq
(FStar.Seq.Permuta... | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.int",
"FStar.IntegerIntervals.not_less_than",
"FStar.IntegerIntervals.ifrom_ito",
"Prims.op_Equality",
"FStar.Seq.Permutation.fold_decomposition_aux",
"Prims.bool",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__c... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_split'
#c
#eq
(cm: CE.cm c eq)
(n0: int)
(nk: not_less_than n0)
(expr1: ((ifrom_ito n0 nk) -> c))
(expr2: ((ifrom_ito n0 nk) -> c))
: Tot
(squash ((foldm_snoc cm
(init (closed_interval_size n0 nk)
(init_func_from_... | if (nk = n0)
then fold_decomposition_aux cm n0 nk expr1 expr2
else
(cm_commutativity cm;
elim_eq_laws eq;
let lfunc_up_to (nf: ifrom_ito n0 nk) = init_func_from_expr (func_sum cm expr1 expr2) n0 nf in
let range_count = closed_interval_size in
let full_count = range_count n0 nk in
let sub_count = r... | false |
LowParseWriters.fsti | LowParseWriters.failwith_repr | val failwith_repr (a: Type) (inv: memory_invariant) (s: string)
: Tot (read_repr a True (fun _ -> False) (fun _ -> True) inv) | val failwith_repr (a: Type) (inv: memory_invariant) (s: string)
: Tot (read_repr a True (fun _ -> False) (fun _ -> True) inv) | let failwith_repr
(a: Type)
(inv: memory_invariant)
(s: string)
: Tot (read_repr a True (fun _ -> False) (fun _ -> True) inv)
= ReadRepr _ (failwith_impl a inv s) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 540,
"start_col": 0,
"start_line": 535
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 -> inv: LowParseWriters.memory_invariant -> s: Prims.string
-> LowParseWriters.read_repr a Prims.l_True (fun _ -> Prims.l_False) (fun _ -> Prims.l_True) inv | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.memory_invariant",
"Prims.string",
"LowParseWriters.ReadRepr",
"Prims.l_True",
"Prims.l_False",
"Prims.unit",
"LowParseWriters.failwith_spec",
"LowParseWriters.failwith_impl",
"LowParseWriters.read_repr"
] | [] | false | false | false | false | false | let failwith_repr (a: Type) (inv: memory_invariant) (s: string)
: Tot (read_repr a True (fun _ -> False) (fun _ -> True) inv) =
| ReadRepr _ (failwith_impl a inv s) | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.fsqrt | val fsqrt: res:felem -> a:felem -> Stack unit
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.prime /\
fmont_as_nat h1 res = S.fsqrt (fmont_as_nat h0 a)) | val fsqrt: res:felem -> a:felem -> Stack unit
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.prime /\
fmont_as_nat h1 res = S.fsqrt (fmont_as_nat h0 a)) | let fsqrt res a =
let h0 = ST.get () in
push_frame ();
let tmp = create 8ul (u64 0) in
let tmp1 = sub tmp 0ul 4ul in
let tmp2 = sub tmp 4ul 4ul in
fsqrt_254 tmp2 tmp1 a;
copy res tmp2;
let h1 = ST.get () in
assert (fmont_as_nat h1 res == SI.fsqrt (fmont_as_nat h0 a));
SI.fsqrt_is_fsqrt_lemma (fmont... | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 313,
"start_col": 0,
"start_line": 302
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"... | {
"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 | res: Hacl.Impl.P256.Bignum.felem -> a: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Spec.P256.Finv.fsqrt_is_fsqrt_lemma",
"Hacl.Impl.P256.Field.fmont_as_nat",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.felem",
"Hacl.Spec.P256.Finv.fsqrt",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStac... | [] | false | true | false | false | false | let fsqrt res a =
| let h0 = ST.get () in
push_frame ();
let tmp = create 8ul (u64 0) in
let tmp1 = sub tmp 0ul 4ul in
let tmp2 = sub tmp 4ul 4ul in
fsqrt_254 tmp2 tmp1 a;
copy res tmp2;
let h1 = ST.get () in
assert (fmont_as_nat h1 res == SI.fsqrt (fmont_as_nat h0 a));
SI.fsqrt_is_fsqrt_lemma (fmont_as_nat h0 a);
pop_frame () | false |
LowParseWriters.fsti | LowParseWriters.ptr | val ptr : p: LowParseWriters.LowParse.parser -> inv: LowParseWriters.memory_invariant -> Type0 | let ptr (p: parser) (inv: memory_invariant) =
(x: rptr { valid_rptr p inv x }) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 658,
"start_col": 0,
"start_line": 657
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: LowParseWriters.LowParse.parser -> inv: LowParseWriters.memory_invariant -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.memory_invariant",
"LowParseWriters.rptr",
"LowParseWriters.valid_rptr"
] | [] | false | false | false | true | true | let ptr (p: parser) (inv: memory_invariant) =
| (x: rptr{valid_rptr p inv x}) | false | |
LowParseWriters.fsti | LowParseWriters.read_repr_spec | val read_repr_spec
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
: Tot (Type u#x) | val read_repr_spec
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
: Tot (Type u#x) | let read_repr_spec (a:Type u#x) (pre: pure_pre) (post: pure_post' a pre) (post_err: pure_post_err pre) : Tot (Type u#x) =
unit ->
Ghost (result a)
(requires pre)
(ensures (fun res ->
match res with
| Correct v -> post v
| Error _ -> post_err ()
)) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 77,
"start_col": 0,
"start_line": 69
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre
-> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"Prims.unit",
"LowParseWriters.result",
"Prims.string"
] | [] | false | false | false | false | true | let read_repr_spec
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
: Tot (Type u#x) =
| unit
-> Ghost (result a)
(requires pre)
(ensures
(function
| Correct v -> post v
| Error _ -> post_err ())) | false |
LowParseWriters.fsti | LowParseWriters.read_bind_spec | val read_bind_spec
(a b: Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
(pre_g: (x: a -> pure_pre))
(post_g: (x: a -> pure_post' b (pre_g x)))
(post_err_g: (x: a -> pure_post_err (pre_g x)))
(f_bind_spec: read_repr_spec a pre_f post... | val read_bind_spec
(a b: Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
(pre_g: (x: a -> pure_pre))
(post_g: (x: a -> pure_post' b (pre_g x)))
(post_err_g: (x: a -> pure_post_err (pre_g x)))
(f_bind_spec: read_repr_spec a pre_f post... | let read_bind_spec
(a:Type) (b:Type)
(pre_f: pure_pre) (post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
(pre_g: (x:a) -> pure_pre) (post_g: (x:a) -> pure_post' b (pre_g x))
(post_err_g: (x: a) -> pure_post_err (pre_g x))
(f_bind_spec: read_repr_spec a pre_f post_f post_err_f)
(g:(x:a -> read... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 203,
"start_col": 0,
"start_line": 187
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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 ->
pre_f: Prims.pure_pre ->
post_f: LowParseWriters.pure_post' a pre_f ->
post_err_f: LowParseWriters.pure_post_err pre_f ->
pre_g: (x: a -> Prims.pure_pre) ->
post_g: (x: a -> LowParseWriters.pure_post' b (pre_g x)) ->
post_err_g: (x: a -> LowParseWriters.pure_post_e... | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.read_repr_spec",
"Prims.unit",
"Prims.string",
"LowParseWriters.Error",
"LowParseWriters.result",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_Exists",
"Prims.l_or"
] | [] | false | false | false | false | false | let read_bind_spec
(a b: Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
(pre_g: (x: a -> pure_pre))
(post_g: (x: a -> pure_post' b (pre_g x)))
(post_err_g: (x: a -> pure_post_err (pre_g x)))
(f_bind_spec: read_repr_spec a pre_f post... | fun _ ->
match f_bind_spec () with
| Correct a -> g a ()
| Error e -> Error e | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.fsqrt_254 | val fsqrt_254 (tmp2 tmp1 a:felem) : Stack unit
(requires fun h ->
live h a /\ live h tmp1 /\ live h tmp2 /\
disjoint a tmp1 /\ disjoint a tmp2 /\ disjoint tmp1 tmp2 /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc tmp1 |+| loc tmp2) h0 h1 /\
as_nat h1 tmp2 < S.prime /\
(let f = fmo... | val fsqrt_254 (tmp2 tmp1 a:felem) : Stack unit
(requires fun h ->
live h a /\ live h tmp1 /\ live h tmp2 /\
disjoint a tmp1 /\ disjoint a tmp2 /\ disjoint tmp1 tmp2 /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc tmp1 |+| loc tmp2) h0 h1 /\
as_nat h1 tmp2 < S.prime /\
(let f = fmo... | let fsqrt_254 tmp2 tmp1 a =
let h0 = ST.get () in
fsquare_times tmp1 a 1ul;
fmul tmp1 tmp1 a;
let h1 = ST.get () in
assert (fmont_as_nat h1 tmp1 == // x2
S.fmul (SI.fsquare_times (fmont_as_nat h0 a) 1) (fmont_as_nat h0 a));
fsquare_times tmp2 tmp1 2ul;
fmul tmp2 tmp2 tmp1;
let h2 = ST.get () in
a... | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 298,
"start_col": 0,
"start_line": 254
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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 |
tmp2: Hacl.Impl.P256.Bignum.felem ->
tmp1: Hacl.Impl.P256.Bignum.felem ->
a: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Finv.fsquare_times_in_place",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.felem",
"Hacl.Impl.P256.Field.fmont_as_nat",
"Spec.P256.PointOps.fmul",
"Hacl.Spec.P256.Finv.fsquare_times",
"FStar.Monotonic.H... | [] | false | true | false | false | false | let fsqrt_254 tmp2 tmp1 a =
| let h0 = ST.get () in
fsquare_times tmp1 a 1ul;
fmul tmp1 tmp1 a;
let h1 = ST.get () in
assert (fmont_as_nat h1 tmp1 == S.fmul (SI.fsquare_times (fmont_as_nat h0 a) 1) (fmont_as_nat h0 a));
fsquare_times tmp2 tmp1 2ul;
fmul tmp2 tmp2 tmp1;
let h2 = ST.get () in
assert (fmont_as_nat h2 tmp2 ==
S.fmul (SI.fsquare_tim... | false |
LowParseWriters.fsti | LowParseWriters.read_subcomp_spec | val read_subcomp_spec
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(f_subcomp: read_repr_spec a pre post post_err)
: Pure (read_repr_spec a pre' post' post_... | val read_subcomp_spec
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(f_subcomp: read_repr_spec a pre post post_err)
: Pure (read_repr_spec a pre' post' post_... | let read_subcomp_spec (a:Type)
(pre: pure_pre) (post: pure_post' a pre) (post_err: pure_post_err pre)
(pre': pure_pre) (post': pure_post' a pre') (post_err': pure_post_err pre')
(f_subcomp:read_repr_spec a pre post post_err)
: Pure (read_repr_spec a pre' post' post_err')
(requires (read_subcomp_spec_cond a pre ... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 268,
"start_col": 0,
"start_line": 261
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
pre': Prims.pure_pre ->
post': LowParseWriters.pure_post' a pre' ->
post_err': LowParseWriters.pure_post_err pre' ->
f_subcomp: LowParseWriters.read_repr_spec a pre... | Prims.Pure | [] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.read_repr_spec",
"Prims.unit",
"LowParseWriters.result",
"LowParseWriters.read_subcomp_spec_cond",
"Prims.l_True"
] | [] | false | false | false | false | false | let read_subcomp_spec
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(f_subcomp: read_repr_spec a pre post post_err)
: Pure (read_repr_spec a pre' post' post_... | (fun x -> f_subcomp x) | false |
LowParseWriters.fsti | LowParseWriters.validate_post_err | val validate_post_err (p: parser) (inv: memory_invariant) (b: B.buffer U8.t)
: Tot (pure_post_err (validate_pre inv b)) | val validate_post_err (p: parser) (inv: memory_invariant) (b: B.buffer U8.t)
: Tot (pure_post_err (validate_pre inv b)) | let validate_post_err
(p: parser)
(inv: memory_invariant)
(b: B.buffer U8.t)
: Tot (pure_post_err (validate_pre inv b))
= fun _ -> forall pos . ~ (valid_pos p inv.h0 b 0ul pos) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 793,
"start_col": 0,
"start_line": 788
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: LowParseWriters.LowParse.parser ->
inv: LowParseWriters.memory_invariant ->
b: LowStar.Buffer.buffer FStar.UInt8.t
-> LowParseWriters.pure_post_err (LowParseWriters.validate_pre inv b) | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.memory_invariant",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.unit",
"Prims.l_Forall",
"FStar.UInt32.t",
"Prims.l_not",
"LowParseWriters.LowParse.valid_pos",
"FStar.Ghost.reveal",
"FStar.Monotonic.HyperStack.mem",
"LowParseWriters.__pro... | [] | false | false | false | false | false | let validate_post_err (p: parser) (inv: memory_invariant) (b: B.buffer U8.t)
: Tot (pure_post_err (validate_pre inv b)) =
| fun _ -> forall pos. ~(valid_pos p inv.h0 b 0ul pos) | false |
LowParseWriters.fsti | LowParseWriters.validate_pre | val validate_pre (inv: memory_invariant) (b: B.buffer U8.t) : Tot pure_pre | val validate_pre (inv: memory_invariant) (b: B.buffer U8.t) : Tot pure_pre | let validate_pre
(inv: memory_invariant)
(b: B.buffer U8.t)
: Tot pure_pre
=
inv.lwrite `B.loc_disjoint` B.loc_buffer b /\
B.live inv.h0 b | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 775,
"start_col": 0,
"start_line": 769
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | inv: LowParseWriters.memory_invariant -> b: LowStar.Buffer.buffer FStar.UInt8.t -> Prims.pure_pre | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.memory_invariant",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"FStar.Ghost.reveal",
"LowStar.Monotonic.Buffer.loc",
"LowParseWriters.__proj__Mkmemory_invariant__item__lwrite",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Bu... | [] | false | false | false | true | false | let validate_pre (inv: memory_invariant) (b: B.buffer U8.t) : Tot pure_pre =
| inv.lwrite `B.loc_disjoint` (B.loc_buffer b) /\ B.live inv.h0 b | false |
LowParseWriters.fsti | LowParseWriters.validate_repr | val validate_repr
(#p: parser)
(v: validator p)
(inv: memory_invariant)
(b: B.buffer U8.t)
(len: U32.t{B.len b == len})
: Tot
(read_repr (ptr p inv & U32.t)
(validate_pre inv b)
(validate_post p inv b)
(validate_post_err p inv b)
inv) | val validate_repr
(#p: parser)
(v: validator p)
(inv: memory_invariant)
(b: B.buffer U8.t)
(len: U32.t{B.len b == len})
: Tot
(read_repr (ptr p inv & U32.t)
(validate_pre inv b)
(validate_post p inv b)
(validate_post_err p inv b)
inv) | let validate_repr
(#p: parser)
(v: validator p)
(inv: memory_invariant)
(b: B.buffer U8.t)
(len: U32.t { B.len b == len })
: Tot (read_repr (ptr p inv & U32.t) (validate_pre inv b) (validate_post p inv b) (validate_post_err p inv b) inv)
= ReadRepr _ (validate_impl v inv b len) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 818,
"start_col": 0,
"start_line": 811
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: LowParseWriters.LowParse.validator p ->
inv: LowParseWriters.memory_invariant ->
b: LowStar.Buffer.buffer FStar.UInt8.t ->
len: FStar.UInt32.t{LowStar.Monotonic.Buffer.len b == len}
-> LowParseWriters.read_repr (LowParseWriters.ptr p inv * FStar.UInt32.t)
(LowParseWriters.validate_pre inv b)... | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.LowParse.validator",
"LowParseWriters.memory_invariant",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowParseWriters.ReadRepr",
"FStar.Pervasives.N... | [] | false | false | false | false | false | let validate_repr
(#p: parser)
(v: validator p)
(inv: memory_invariant)
(b: B.buffer U8.t)
(len: U32.t{B.len b == len})
: Tot
(read_repr (ptr p inv & U32.t)
(validate_pre inv b)
(validate_post p inv b)
(validate_post_err p inv b)
inv) =
| ReadRepr _ (validate_impl v inv b len) | false |
LowParseWriters.fsti | LowParseWriters.read_return_spec | val read_return_spec (a: Type) (x: a)
: Tot (read_repr_spec a True (fun res -> res == x) (fun _ -> False)) | val read_return_spec (a: Type) (x: a)
: Tot (read_repr_spec a True (fun res -> res == x) (fun _ -> False)) | let read_return_spec
(a:Type) (x:a)
: Tot (read_repr_spec a True (fun res -> res == x) (fun _ -> False))
= fun _ -> Correct x | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 149,
"start_col": 0,
"start_line": 146
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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
-> LowParseWriters.read_repr_spec a Prims.l_True (fun res -> res == x) (fun _ -> Prims.l_False) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"LowParseWriters.Correct",
"LowParseWriters.result",
"LowParseWriters.read_repr_spec",
"Prims.l_True",
"Prims.eq2",
"Prims.l_False"
] | [] | false | false | false | false | false | let read_return_spec (a: Type) (x: a)
: Tot (read_repr_spec a True (fun res -> res == x) (fun _ -> False)) =
| fun _ -> Correct x | false |
LowParseWriters.fsti | LowParseWriters.read_bind | val read_bind
(a b: Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
([@@@ refl_implicit]l_f: memory_invariant)
(pre_g: (x: a -> pure_pre))
(post_g: (x: a -> pure_post' b (pre_g x)))
(post_err_g: (x: a -> pure_post_err (pre_g x)))
... | val read_bind
(a b: Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
([@@@ refl_implicit]l_f: memory_invariant)
(pre_g: (x: a -> pure_pre))
(post_g: (x: a -> pure_post' b (pre_g x)))
(post_err_g: (x: a -> pure_post_err (pre_g x)))
... | let read_bind
(a:Type) (b:Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
([@@@ refl_implicit] l_f:memory_invariant)
(pre_g: (x:a) -> pure_pre) (post_g: (x:a) -> pure_post' b (pre_g x))
(post_err_g: (x: a) -> pure_post_err (pre_g x))
([@@@ refl_implicit] l_g: memor... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 198,
"end_line": 238,
"start_col": 0,
"start_line": 220
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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 ->
pre_f: Prims.pure_pre ->
post_f: LowParseWriters.pure_post' a pre_f ->
post_err_f: LowParseWriters.pure_post_err pre_f ->
l_f: LowParseWriters.memory_invariant ->
pre_g: (x: a -> Prims.pure_pre) ->
post_g: (x: a -> LowParseWriters.pure_post' b (pre_g x)) ->
pos... | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.memory_invariant",
"Prims.squash",
"Prims.eq2",
"LowParseWriters.read_repr",
"LowParseWriters.ReadRepr",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_Exists",
"Prims.unit",
"Prims.... | [] | false | false | false | false | false | let read_bind
(a b: Type)
(pre_f: pure_pre)
(post_f: pure_post' a pre_f)
(post_err_f: pure_post_err pre_f)
([@@@ refl_implicit]l_f: memory_invariant)
(pre_g: (x: a -> pure_pre))
(post_g: (x: a -> pure_post' b (pre_g x)))
(post_err_g: (x: a -> pure_post_err (pre_g x)))
... | ReadRepr _
(read_bind_impl a b pre_f post_f post_err_f pre_g post_g post_err_g (ReadRepr?.spec f_bind)
(fun x -> ReadRepr?.spec (g x)) l_g (ReadRepr?.impl f_bind) (fun x -> ReadRepr?.impl (g x))) | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.finv | val finv: res:felem -> a:felem -> Stack unit
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.prime /\
fmont_as_nat h1 res = S.finv (fmont_as_nat h0 a)) | val finv: res:felem -> a:felem -> Stack unit
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res /\
as_nat h a < S.prime)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.prime /\
fmont_as_nat h1 res = S.finv (fmont_as_nat h0 a)) | let finv res a =
let h0 = ST.get () in
push_frame ();
let tmp = create 16ul (u64 0) in
let x30 = sub tmp 0ul 4ul in
let x2 = sub tmp 4ul 4ul in
let tmp1 = sub tmp 8ul 4ul in
let tmp2 = sub tmp 12ul 4ul in
finv_30 x30 x2 tmp1 tmp2 a;
finv_256 tmp1 x2 x30 a;
copy res tmp1;
let h1 = ST.get () in
... | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 232,
"start_col": 0,
"start_line": 218
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"... | {
"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 | res: Hacl.Impl.P256.Bignum.felem -> a: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Spec.P256.Finv.finv_is_finv_lemma",
"Hacl.Impl.P256.Field.fmont_as_nat",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.felem",
"Hacl.Spec.P256.Finv.finv",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.S... | [] | false | true | false | false | false | let finv res a =
| let h0 = ST.get () in
push_frame ();
let tmp = create 16ul (u64 0) in
let x30 = sub tmp 0ul 4ul in
let x2 = sub tmp 4ul 4ul in
let tmp1 = sub tmp 8ul 4ul in
let tmp2 = sub tmp 12ul 4ul in
finv_30 x30 x2 tmp1 tmp2 a;
finv_256 tmp1 x2 x30 a;
copy res tmp1;
let h1 = ST.get () in
assert (fmont_as_nat h1 res == SI.finv (fmo... | false |
Steel.Effect.Atomic.fst | Steel.Effect.Atomic.change_equal_slprop | val change_equal_slprop (#opened:inames) (p q: vprop)
: SteelGhost unit opened p (fun _ -> q) (fun _ -> p == q) (fun h0 _ h1 -> p == q /\ h1 q == h0 p) | val change_equal_slprop (#opened:inames) (p q: vprop)
: SteelGhost unit opened p (fun _ -> q) (fun _ -> p == q) (fun h0 _ h1 -> p == q /\ h1 q == h0 p) | let change_equal_slprop
p q
= let m = get () in
let x : Ghost.erased (t_of p) = hide ((reveal m) p) in
let y : Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop
p
q
x
y
(fun _ -> ()) | {
"file_name": "lib/steel/Steel.Effect.Atomic.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 17,
"end_line": 438,
"start_col": 0,
"start_line": 428
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.fst.checked",
"Steel.Effect.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.NMSTTotal.fst.che... | [
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "Sem"
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.Effect.Common.vprop -> q: Steel.Effect.Common.vprop
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.change_slprop",
"Steel.Memory.mem",
"Prims.unit",
"FStar.Ghost.erased",
"Steel.Effect.Common.t_of",
"FStar.Ghost.hide",
"FStar.Ghost.reveal",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.v... | [] | false | true | false | false | false | let change_equal_slprop p q =
| let m = get () in
let x:Ghost.erased (t_of p) = hide ((reveal m) p) in
let y:Ghost.erased (t_of q) = Ghost.hide (Ghost.reveal x) in
change_slprop p q x y (fun _ -> ()) | false |
LowParseWriters.fsti | LowParseWriters.read_subcomp | val read_subcomp
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(l': memory_invariant)
(f_subcomp: read_repr a pre post post_err... | val read_subcomp
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(l': memory_invariant)
(f_subcomp: read_repr a pre post post_err... | let read_subcomp (a:Type)
(pre: pure_pre) (post: pure_post' a pre) (post_err: pure_post_err pre)
(l:memory_invariant)
(pre': pure_pre) (post': pure_post' a pre') (post_err': pure_post_err pre')
(l' : memory_invariant)
(f_subcomp:read_repr a pre post post_err l)
: Pure (read_repr a pre' post' post_err' l')
(... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 293,
"start_col": 0,
"start_line": 282
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
l: LowParseWriters.memory_invariant ->
pre': Prims.pure_pre ->
post': LowParseWriters.pure_post' a pre' ->
post_err': LowParseWriters.pure_post_err pre' ->
l': ... | Prims.Pure | [] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.memory_invariant",
"LowParseWriters.read_repr",
"LowParseWriters.ReadRepr",
"LowParseWriters.read_subcomp_spec",
"LowParseWriters.__proj__ReadRepr__item__spec",
"LowParseWriters.read_subcomp_impl",
"L... | [] | false | false | false | false | false | let read_subcomp
(a: Type)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
(pre': pure_pre)
(post': pure_post' a pre')
(post_err': pure_post_err pre')
(l': memory_invariant)
(f_subcomp: read_repr a pre post post_err... | ReadRepr (read_subcomp_spec a pre post post_err pre' post' post_err' (ReadRepr?.spec f_subcomp))
(read_subcomp_impl a pre post post_err pre' post' post_err' l l' (ReadRepr?.spec f_subcomp)
(ReadRepr?.impl f_subcomp) ()) | false |
Steel.Channel.Simplex.fst | Steel.Channel.Simplex.recv | val recv (#p:prot) (#next:prot{more next}) (c:chan p)
: SteelT (msg_t next) (receiver c next) (fun x -> receiver c (step next x)) | val recv (#p:prot) (#next:prot{more next}) (c:chan p)
: SteelT (msg_t next) (receiver c next) (fun x -> receiver c (step next x)) | let rec recv (#p:prot) (#next:prot{more next}) (c:chan p)
: SteelT (msg_t next) (receiver c next) (fun x -> receiver c (step next x))
= let v = send_receive_prelude c in
if (fst v).chan_ctr = (snd v).chan_ctr
then (
rewrite_slprop (chan_inv_cond (fst v) (snd v))
(pure ... | {
"file_name": "lib/steel/Steel.Channel.Simplex.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 408,
"start_col": 0,
"start_line": 390
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Utils.fst.checked",
"Steel.SpinLock.fsti.checked",
"Steel.MonotonicHigherReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked... | [
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.MonotonicHigherReference",
"short_module": "MRef"
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"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 | c: Steel.Channel.Simplex.chan p -> Steel.Effect.SteelT (Steel.Channel.Protocol.msg_t next) | Steel.Effect.SteelT | [] | [] | [
"Steel.Channel.Simplex.prot",
"Prims.b2t",
"Steel.Channel.Protocol.more",
"Steel.Channel.Simplex.chan",
"Prims.op_Equality",
"Prims.nat",
"Steel.Channel.Simplex.__proj__Mkchan_val__item__chan_ctr",
"FStar.Pervasives.Native.fst",
"Steel.Channel.Simplex.chan_val",
"FStar.Pervasives.Native.snd",
"S... | [
"recursion"
] | false | true | false | false | false | let rec recv (#p: prot) (#next: prot{more next}) (c: chan p)
: SteelT (msg_t next) (receiver c next) (fun x -> receiver c (step next x)) =
| let v = send_receive_prelude c in
if (fst v).chan_ctr = (snd v).chan_ctr
then
(rewrite_slprop (chan_inv_cond (fst v) (snd v)) (pure (fst v == snd v)) (fun _ -> ());
elim_pure (fst v == snd v);
intro_chan_inv_eqT c.chan_chan (fst v) (snd v);
Steel.SpinLock.release c.chan_lock;
recv c)
else
(rewrite_s... | false |
LowParseWriters.fsti | LowParseWriters.buffer_offset | val buffer_offset (#t: Type) (b: B.buffer t) : Tot Type0 | val buffer_offset (#t: Type) (b: B.buffer t) : Tot Type0 | let buffer_offset
(#t: Type)
(b: B.buffer t)
: Tot Type0
= pos1: U32.t { U32.v pos1 <= B.length b } | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 909,
"start_col": 0,
"start_line": 905
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | b: LowStar.Buffer.buffer t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let buffer_offset (#t: Type) (b: B.buffer t) : Tot Type0 =
| pos1: U32.t{U32.v pos1 <= B.length b} | false |
LowParseWriters.fsti | LowParseWriters.try_rewrite_equality | val try_rewrite_equality (x: term) (bs: binders) : Tac unit | val try_rewrite_equality (x: term) (bs: binders) : Tac unit | let rec try_rewrite_equality (x:term) (bs:binders) : Tac unit =
match bs with
| [] -> ()
| x_t::bs ->
begin match term_as_formula' x_t.sort with
| Comp (Eq _) y _ ->
if term_eq x y
then rewrite (binder_to_binding x_t)
else try_rewrite_equality x bs
... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 453,
"start_col": 0,
"start_line": 442
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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.Tactics.NamedView.term -> bs: FStar.Tactics.NamedView.binders
-> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.term",
"FStar.Tactics.NamedView.binders",
"Prims.unit",
"FStar.Tactics.NamedView.binder",
"Prims.list",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Stubs.Reflection.V2.Builtins.term_eq",
"FStar.Stubs.Tactics.V2.Builtins.rewrite",
"FStar.Tac... | [
"recursion"
] | false | true | false | false | false | let rec try_rewrite_equality (x: term) (bs: binders) : Tac unit =
| match bs with
| [] -> ()
| x_t :: bs ->
match term_as_formula' x_t.sort with
| Comp (Eq _) y _ ->
if term_eq x y then rewrite (binder_to_binding x_t) else try_rewrite_equality x bs
| _ -> try_rewrite_equality x bs | false |
LowParseWriters.fsti | LowParseWriters.lift_pure_read_spec | val lift_pure_read_spec (a: Type) (wp: pure_wp a) (f_pure_spec: (unit -> PURE a wp))
: Tot
(read_repr_spec a (wp (fun _ -> True)) (fun x -> ~(wp (fun x' -> ~(x == x')))) (fun _ -> False)) | val lift_pure_read_spec (a: Type) (wp: pure_wp a) (f_pure_spec: (unit -> PURE a wp))
: Tot
(read_repr_spec a (wp (fun _ -> True)) (fun x -> ~(wp (fun x' -> ~(x == x')))) (fun _ -> False)) | let lift_pure_read_spec
(a:Type) (wp:pure_wp a) (f_pure_spec:unit -> PURE a wp)
: Tot (read_repr_spec a
(wp (fun _ -> True)) // (lift_pure_read_pre a wp)
(fun x -> ~ (wp (fun x' -> ~ (x == x')))) // (lift_pure_read_post a wp)
(fun _ -> False) // (lift_pure_read_post_err a wp))
)
= FStar.Monotonic.Pure.... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 341,
"start_col": 0,
"start_line": 333
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_mod... | {
"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: Prims.pure_wp a -> f_pure_spec: (_: Prims.unit -> Prims.PURE a)
-> LowParseWriters.read_repr_spec a
(wp (fun _ -> Prims.l_True))
(fun x -> ~(wp (fun x' -> ~(x == x'))))
(fun _ -> Prims.l_False) | Prims.Tot | [
"total"
] | [] | [
"Prims.pure_wp",
"Prims.unit",
"LowParseWriters.Correct",
"LowParseWriters.result",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"LowParseWriters.read_repr_spec",
"Prims.l_True",
"Prims.l_not",
"Prims.eq2",
"Prims.l_False"
] | [] | false | false | false | false | false | let lift_pure_read_spec (a: Type) (wp: pure_wp a) (f_pure_spec: (unit -> PURE a wp))
: Tot
(read_repr_spec a (wp (fun _ -> True)) (fun x -> ~(wp (fun x' -> ~(x == x')))) (fun _ -> False)) =
| FStar.Monotonic.Pure.elim_pure_wp_monotonicity wp;
fun () -> Correct (f_pure_spec ()) | false |
LowParseWriters.fsti | LowParseWriters.reify_read | val reify_read
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: HST.Stack (result a)
(requires
(fun h ->
B.modifies l.lwrite l.h0 h /\ (HS.get_tip l.h... | val reify_read
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: HST.Stack (result a)
(requires
(fun h ->
B.modifies l.lwrite l.h0 h /\ (HS.get_tip l.h... | let reify_read
(a:Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: unit -> ERead a pre post post_err l)
: HST.Stack (result a)
(requires (fun h ->
B.modifies l.lwrite l.h0 h /\
HS.get_tip l.h0 `HS.includes` HS.get_tip h /\
pre
... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 407,
"start_col": 0,
"start_line": 389
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: Prims.pure_pre ->
post: LowParseWriters.pure_post' a pre ->
post_err: LowParseWriters.pure_post_err pre ->
l: LowParseWriters.memory_invariant ->
$r: (_: Prims.unit -> LowParseWriters.ERead a)
-> FStar.HyperStack.ST.Stack (LowParseWriters.result a) | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.pure_pre",
"LowParseWriters.pure_post'",
"LowParseWriters.pure_post_err",
"LowParseWriters.memory_invariant",
"Prims.unit",
"LowParseWriters.extract_read_repr_impl",
"LowParseWriters.destr_read_repr_spec",
"LowParseWriters.destr_read_repr_impl",
"LowParseWriters.result",
"FStar.Monotonic.Hy... | [] | false | true | false | false | false | let reify_read
(a: Type u#x)
(pre: pure_pre)
(post: pure_post' a pre)
(post_err: pure_post_err pre)
(l: memory_invariant)
($r: (unit -> ERead a pre post post_err l))
: HST.Stack (result a)
(requires
(fun h ->
B.modifies l.lwrite l.h0 h /\ (HS.get_tip l.h... | extract_read_repr_impl _ _ _ _ _ _ (destr_read_repr_impl _ _ _ _ _ r) | false |
Hacl.Impl.P256.Finv.fst | Hacl.Impl.P256.Finv.finv_30 | val finv_30 (x30 x2 tmp1 tmp2 a:felem) : Stack unit
(requires fun h ->
live h a /\ live h x30 /\ live h x2 /\ live h tmp1 /\ live h tmp2 /\
disjoint a x30 /\ disjoint a x2 /\ disjoint a tmp1 /\ disjoint a tmp2 /\
disjoint x30 x2 /\ disjoint x30 tmp1 /\ disjoint x30 tmp2 /\
disjoint x2 tmp1 /\ disjoint... | val finv_30 (x30 x2 tmp1 tmp2 a:felem) : Stack unit
(requires fun h ->
live h a /\ live h x30 /\ live h x2 /\ live h tmp1 /\ live h tmp2 /\
disjoint a x30 /\ disjoint a x2 /\ disjoint a tmp1 /\ disjoint a tmp2 /\
disjoint x30 x2 /\ disjoint x30 tmp1 /\ disjoint x30 tmp2 /\
disjoint x2 tmp1 /\ disjoint... | let finv_30 x30 x2 tmp1 tmp2 a =
let h0 = ST.get () in
fsquare_times x2 a 1ul;
fmul x2 x2 a;
let h1 = ST.get () in
assert (fmont_as_nat h1 x2 ==
S.fmul (SI.fsquare_times (fmont_as_nat h0 a) 1) (fmont_as_nat h0 a));
fsquare_times x30 x2 1ul;
fmul x30 x30 a;
let h2 = ST.get () in
assert (fmont_as_n... | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Finv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 155,
"start_col": 0,
"start_line": 119
} | module Hacl.Impl.P256.Finv
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Field
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module BD = Hacl.Spec.Bignum.Definitio... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.P256.Finv.fst.checked",... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Finv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_m... | {
"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 |
x30: Hacl.Impl.P256.Bignum.felem ->
x2: Hacl.Impl.P256.Bignum.felem ->
tmp1: Hacl.Impl.P256.Bignum.felem ->
tmp2: Hacl.Impl.P256.Bignum.felem ->
a: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.felem",
"Hacl.Impl.P256.Field.fmont_as_nat",
"Spec.P256.PointOps.fmul",
"Hacl.Spec.P256.Finv.fsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.P256.Field.fmul",
... | [] | false | true | false | false | false | let finv_30 x30 x2 tmp1 tmp2 a =
| let h0 = ST.get () in
fsquare_times x2 a 1ul;
fmul x2 x2 a;
let h1 = ST.get () in
assert (fmont_as_nat h1 x2 == S.fmul (SI.fsquare_times (fmont_as_nat h0 a) 1) (fmont_as_nat h0 a));
fsquare_times x30 x2 1ul;
fmul x30 x30 a;
let h2 = ST.get () in
assert (fmont_as_nat h2 x30 == S.fmul (SI.fsquare_times (fmont_as_nat h1 x... | false |
LowParseWriters.fsti | LowParseWriters.returnc | val returnc (a: Type) (x: a) (r: parser) (l: memory_invariant)
: Tot
(repr a (r) r (fun _ -> True) (fun v_in x' v_out -> x' == x /\ v_out == v_in) (fun _ -> False) l
) | val returnc (a: Type) (x: a) (r: parser) (l: memory_invariant)
: Tot
(repr a (r) r (fun _ -> True) (fun v_in x' v_out -> x' == x /\ v_out == v_in) (fun _ -> False) l
) | let returnc
(a:Type) (x:a) (r: parser) (l: memory_invariant)
: Tot (repr a (r) r (fun _ -> True) (fun v_in x' v_out -> x' == x /\ v_out == v_in) (fun _ -> False) l)
= Repr (return_spec a x r) (return_impl a x r l) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 1005,
"start_col": 0,
"start_line": 1002
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 -> r: LowParseWriters.LowParse.parser -> l: LowParseWriters.memory_invariant
-> LowParseWriters.repr a
r
r
(fun _ -> Prims.l_True)
(fun v_in x' v_out -> x' == x /\ v_out == v_in)
(fun _ -> Prims.l_False)
l | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.memory_invariant",
"LowParseWriters.Repr",
"LowParseWriters.LowParse.__proj__Parser__item__t",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.l_False",
"LowParseWriters.return_spec",
"LowParseWriters.return_impl",
"LowParseWriters.repr"
] | [] | false | false | false | false | false | let returnc (a: Type) (x: a) (r: parser) (l: memory_invariant)
: Tot
(repr a (r) r (fun _ -> True) (fun v_in x' v_out -> x' == x /\ v_out == v_in) (fun _ -> False) l
) =
| Repr (return_spec a x r) (return_impl a x r l) | false |
LowParseWriters.fsti | LowParseWriters.rewrite_all_context_equalities | val rewrite_all_context_equalities (bs: binders) : Tac unit | val rewrite_all_context_equalities (bs: binders) : Tac unit | let rec rewrite_all_context_equalities (bs:binders) : Tac unit =
match bs with
| [] -> ()
| x_t::bs -> begin
(try rewrite (binder_to_binding x_t) with | _ -> ());
rewrite_all_context_equalities bs
end | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 461,
"start_col": 0,
"start_line": 455
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | bs: FStar.Tactics.NamedView.binders -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.binders",
"Prims.unit",
"FStar.Tactics.NamedView.binder",
"Prims.list",
"LowParseWriters.rewrite_all_context_equalities",
"FStar.Tactics.V2.Derived.try_with",
"FStar.Stubs.Tactics.V2.Builtins.rewrite",
"FStar.Tactics.NamedView.binder_to_binding",
"Prims.exn"
] | [
"recursion"
] | false | true | false | false | false | let rec rewrite_all_context_equalities (bs: binders) : Tac unit =
| match bs with
| [] -> ()
| x_t :: bs ->
(try rewrite (binder_to_binding x_t) with | _ -> ());
rewrite_all_context_equalities bs | false |
LowParseWriters.fsti | LowParseWriters.pick_next | val pick_next (fuel: nat) : Tac bool | val pick_next (fuel: nat) : Tac bool | let rec pick_next (fuel:nat) : Tac bool =
if fuel = 0
then false
else match goals () with
| [] -> false
| hd::tl ->
(match is_eq (goal_type hd) with
| Some (l, r) ->
let b1 = is_uvar l in
let b2 = is_uvar r in
if b1 && b2
then begin
... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 440,
"start_col": 0,
"start_line": 424
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | fuel: Prims.nat -> FStar.Tactics.Effect.Tac Prims.bool | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Stubs.Tactics.Types.goal",
"Prims.list",
"FStar.Tactics.NamedView.term",
"Prims.op_AmpAmp",
"LowParseWriters.pick_next",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Tactics.V2.Derived.later",
"LowParseWriters.is_uvar",
"F... | [
"recursion"
] | false | true | false | false | false | let rec pick_next (fuel: nat) : Tac bool =
| if fuel = 0
then false
else
match goals () with
| [] -> false
| hd :: tl ->
(match is_eq (goal_type hd) with
| Some (l, r) ->
let b1 = is_uvar l in
let b2 = is_uvar r in
if b1 && b2
then
(later ();
pick_next (fuel - 1))
else true
| None... | false |
LowParseWriters.fsti | LowParseWriters.test_read1 | val test_read1 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv | val test_read1 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv | let test_read1
(inv: memory_invariant)
(f: unit -> Read bool (True) (fun _ -> True) inv)
: Read bool (True) (fun _ -> True) inv
= let x = f () in
false | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 501,
"start_col": 0,
"start_line": 496
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | inv: LowParseWriters.memory_invariant -> f: (_: Prims.unit -> LowParseWriters.Read Prims.bool)
-> LowParseWriters.Read Prims.bool | LowParseWriters.Read | [] | [] | [
"LowParseWriters.memory_invariant",
"Prims.unit",
"Prims.bool",
"Prims.l_True"
] | [] | false | true | false | false | false | let test_read1 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv =
| let x = f () in
false | false |
LowParseWriters.fsti | LowParseWriters.failwith | val failwith (#a: Type) (#inv: memory_invariant) (s: string)
: ERead a True (fun _ -> False) (fun _ -> True) inv | val failwith (#a: Type) (#inv: memory_invariant) (s: string)
: ERead a True (fun _ -> False) (fun _ -> True) inv | let failwith
(#a: Type)
(#inv: memory_invariant)
(s: string)
: ERead a True (fun _ -> False) (fun _ -> True) inv
= ERead?.reflect (failwith_repr a inv s) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 548,
"start_col": 0,
"start_line": 543
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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: Prims.string -> LowParseWriters.ERead a | LowParseWriters.ERead | [] | [] | [
"LowParseWriters.memory_invariant",
"Prims.string",
"LowParseWriters.failwith_repr",
"Prims.l_True",
"Prims.l_False",
"Prims.unit"
] | [] | false | true | false | false | false | let failwith (#a: Type) (#inv: memory_invariant) (s: string)
: ERead a True (fun _ -> False) (fun _ -> True) inv =
| ERead?.reflect (failwith_repr a inv s) | false |
LowParseWriters.fsti | LowParseWriters.subcomp_cond | val subcomp_cond
(a: Type)
(r_in r_out: parser)
(pre: pre_t r_in)
(post: post_t a r_in r_out pre)
(post_err: post_err_t r_in pre)
(pre': pre_t r_in)
(post': post_t a r_in r_out pre')
(post_err': post_err_t r_in pre')
(l l': memory_invariant)
: GTot Type0 | val subcomp_cond
(a: Type)
(r_in r_out: parser)
(pre: pre_t r_in)
(post: post_t a r_in r_out pre)
(post_err: post_err_t r_in pre)
(pre': pre_t r_in)
(post': post_t a r_in r_out pre')
(post_err': post_err_t r_in pre')
(l l': memory_invariant)
: GTot Type0 | let subcomp_cond
(a:Type)
(r_in:parser) (r_out: parser)
(pre: pre_t r_in) (post: post_t a r_in r_out pre) (post_err: post_err_t r_in pre)
(pre': pre_t r_in) (post': post_t a r_in r_out pre') (post_err': post_err_t r_in pre')
(l: memory_invariant)
(l' : memory_invariant)
: GTot Type0
= l `memory_invariant_in... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 1095,
"start_col": 0,
"start_line": 1086
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 ->
r_in: LowParseWriters.LowParse.parser ->
r_out: LowParseWriters.LowParse.parser ->
pre: LowParseWriters.pre_t r_in ->
post: LowParseWriters.post_t a r_in r_out pre ->
post_err: LowParseWriters.post_err_t r_in pre ->
pre': LowParseWriters.pre_t r_in ->
post': LowParseWriters.p... | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.pre_t",
"LowParseWriters.post_t",
"LowParseWriters.post_err_t",
"LowParseWriters.memory_invariant",
"Prims.l_and",
"LowParseWriters.memory_invariant_includes",
"LowParseWriters.subcomp_spec_cond"
] | [] | false | false | false | false | true | let subcomp_cond
(a: Type)
(r_in r_out: parser)
(pre: pre_t r_in)
(post: post_t a r_in r_out pre)
(post_err: post_err_t r_in pre)
(pre': pre_t r_in)
(post': post_t a r_in r_out pre')
(post_err': post_err_t r_in pre')
(l l': memory_invariant)
: GTot Type0 =
| l `memory_invariant_includes` l' /\
subcomp_spec_cond a r_in r_out pre post post_err pre' post' post_err' | false |
LowParseWriters.fsti | LowParseWriters.test_read2 | val test_read2 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv | val test_read2 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv | let test_read2
(inv: memory_invariant)
(f: unit -> Read bool (True) (fun _ -> True) inv)
: Read bool (True) (fun _ -> True) inv
= let x = f () in
let x = f () in
false | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 509,
"start_col": 0,
"start_line": 503
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | inv: LowParseWriters.memory_invariant -> f: (_: Prims.unit -> LowParseWriters.Read Prims.bool)
-> LowParseWriters.Read Prims.bool | LowParseWriters.Read | [] | [] | [
"LowParseWriters.memory_invariant",
"Prims.unit",
"Prims.bool",
"Prims.l_True"
] | [] | false | true | false | false | false | let test_read2 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv =
| let x = f () in
let x = f () in
false | false |
LowParseWriters.fsti | LowParseWriters.deref | val deref (#p: parser) (#inv: memory_invariant) (r: leaf_reader p) (x: ptr p inv)
: Read (Parser?.t p) True (fun res -> res == deref_spec x) inv | val deref (#p: parser) (#inv: memory_invariant) (r: leaf_reader p) (x: ptr p inv)
: Read (Parser?.t p) True (fun res -> res == deref_spec x) inv | let deref
(#p: parser)
(#inv: memory_invariant)
(r: leaf_reader p)
(x: ptr p inv)
: Read (Parser?.t p) True (fun res -> res == deref_spec x) inv
= Read?.reflect (deref_repr r x) | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 724,
"start_col": 0,
"start_line": 718
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | r: LowParseWriters.LowParse.leaf_reader p -> x: LowParseWriters.ptr p inv
-> LowParseWriters.Read (Parser?.t p) | LowParseWriters.Read | [] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.memory_invariant",
"LowParseWriters.LowParse.leaf_reader",
"LowParseWriters.ptr",
"LowParseWriters.deref_repr",
"LowParseWriters.LowParse.__proj__Parser__item__t",
"Prims.l_True",
"Prims.eq2",
"LowParseWriters.deref_spec"
] | [] | false | true | false | false | false | let deref (#p: parser) (#inv: memory_invariant) (r: leaf_reader p) (x: ptr p inv)
: Read (Parser?.t p) True (fun res -> res == deref_spec x) inv =
| Read?.reflect (deref_repr r x) | false |
LowParseWriters.fsti | LowParseWriters.subcomp_spec_cond | val subcomp_spec_cond
(a: Type)
(r_in r_out: parser)
(pre: pre_t r_in)
(post: post_t a r_in r_out pre)
(post_err: post_err_t r_in pre)
(pre': pre_t r_in)
(post': post_t a r_in r_out pre')
(post_err': post_err_t r_in pre')
: GTot Type0 | val subcomp_spec_cond
(a: Type)
(r_in r_out: parser)
(pre: pre_t r_in)
(post: post_t a r_in r_out pre)
(post_err: post_err_t r_in pre)
(pre': pre_t r_in)
(post': post_t a r_in r_out pre')
(post_err': post_err_t r_in pre')
: GTot Type0 | let subcomp_spec_cond
(a:Type)
(r_in:parser) (r_out: parser)
(pre: pre_t r_in) (post: post_t a r_in r_out pre) (post_err: post_err_t r_in pre)
(pre': pre_t r_in) (post': post_t a r_in r_out pre') (post_err': post_err_t r_in pre')
: GTot Type0
= (forall v_in . pre' v_in ==> pre v_in) /\
(forall v_in x v_out . ... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 1083,
"start_col": 0,
"start_line": 1075
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 ->
r_in: LowParseWriters.LowParse.parser ->
r_out: LowParseWriters.LowParse.parser ->
pre: LowParseWriters.pre_t r_in ->
post: LowParseWriters.post_t a r_in r_out pre ->
post_err: LowParseWriters.post_err_t r_in pre ->
pre': LowParseWriters.pre_t r_in ->
post': LowParseWriters.p... | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParseWriters.LowParse.parser",
"LowParseWriters.pre_t",
"LowParseWriters.post_t",
"LowParseWriters.post_err_t",
"Prims.l_and",
"Prims.l_Forall",
"LowParseWriters.LowParse.__proj__Parser__item__t",
"Prims.l_imp"
] | [] | false | false | false | false | true | let subcomp_spec_cond
(a: Type)
(r_in r_out: parser)
(pre: pre_t r_in)
(post: post_t a r_in r_out pre)
(post_err: post_err_t r_in pre)
(pre': pre_t r_in)
(post': post_t a r_in r_out pre')
(post_err': post_err_t r_in pre')
: GTot Type0 =
| (forall v_in. pre' v_in ==> pre v_in) /\
(forall v_in x v_out. (pre' v_in /\ post v_in x v_out) ==> post' v_in x v_out) /\
(forall v_in. (pre' v_in /\ post_err v_in) ==> post_err' v_in) | false |
LowParseWriters.fsti | LowParseWriters.failwith_spec | val failwith_spec (a: Type) (s: string)
: Tot (read_repr_spec a True (fun _ -> False) (fun _ -> True)) | val failwith_spec (a: Type) (s: string)
: Tot (read_repr_spec a True (fun _ -> False) (fun _ -> True)) | let failwith_spec
(a: Type)
(s: string)
: Tot (read_repr_spec a True (fun _ -> False) (fun _ -> True))
= fun _ -> Error s | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 525,
"start_col": 0,
"start_line": 521
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 -> s: Prims.string
-> LowParseWriters.read_repr_spec a Prims.l_True (fun _ -> Prims.l_False) (fun _ -> Prims.l_True) | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.unit",
"LowParseWriters.Error",
"LowParseWriters.result",
"LowParseWriters.read_repr_spec",
"Prims.l_True",
"Prims.l_False"
] | [] | false | false | false | false | false | let failwith_spec (a: Type) (s: string)
: Tot (read_repr_spec a True (fun _ -> False) (fun _ -> True)) =
| fun _ -> Error s | false |
LowParseWriters.fsti | LowParseWriters.buffer_sub_spec | val buffer_sub_spec
(#t: Type)
(inv: memory_invariant)
(b: B.buffer t)
(i: U32.t)
(len: Ghost.erased U32.t)
: Tot
(read_repr_spec (B.buffer t)
(B.live inv.h0 b /\ (B.loc_buffer b) `B.loc_disjoint` inv.lwrite /\
U32.v i + U32.v len <= B.length b)
(fun res -... | val buffer_sub_spec
(#t: Type)
(inv: memory_invariant)
(b: B.buffer t)
(i: U32.t)
(len: Ghost.erased U32.t)
: Tot
(read_repr_spec (B.buffer t)
(B.live inv.h0 b /\ (B.loc_buffer b) `B.loc_disjoint` inv.lwrite /\
U32.v i + U32.v len <= B.length b)
(fun res -... | let buffer_sub_spec
(#t: Type)
(inv: memory_invariant)
(b: B.buffer t)
(i: U32.t)
(len: Ghost.erased U32.t)
: Tot (read_repr_spec (B.buffer t)
(
B.live inv.h0 b /\
B.loc_buffer b `B.loc_disjoint` inv.lwrite /\
U32.v i + U32.v len <= B.length b
)
(fun res ->
U32.v i + U32.v... | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 620,
"start_col": 0,
"start_line": 599
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 |
inv: LowParseWriters.memory_invariant ->
b: LowStar.Buffer.buffer t ->
i: FStar.UInt32.t ->
len: FStar.Ghost.erased FStar.UInt32.t
-> LowParseWriters.read_repr_spec (LowStar.Buffer.buffer t)
(LowStar.Monotonic.Buffer.live (FStar.Ghost.reveal (Mkmemory_invariant?.h0 inv)) b /\
LowStar.Mo... | Prims.Tot | [
"total"
] | [] | [
"LowParseWriters.memory_invariant",
"LowStar.Buffer.buffer",
"FStar.UInt32.t",
"FStar.Ghost.erased",
"Prims.unit",
"LowParseWriters.Correct",
"LowStar.Buffer.gsub",
"FStar.Ghost.reveal",
"LowParseWriters.result",
"LowParseWriters.read_repr_spec",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",... | [] | false | false | false | false | false | let buffer_sub_spec
(#t: Type)
(inv: memory_invariant)
(b: B.buffer t)
(i: U32.t)
(len: Ghost.erased U32.t)
: Tot
(read_repr_spec (B.buffer t)
(B.live inv.h0 b /\ (B.loc_buffer b) `B.loc_disjoint` inv.lwrite /\
U32.v i + U32.v len <= B.length b)
(fun res -... | fun _ -> Correct (B.gsub b i len) | false |
LowParseWriters.fsti | LowParseWriters.test_read3 | val test_read3 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv | val test_read3 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv | let test_read3
(inv: memory_invariant)
(f: unit -> Read bool (True) (fun _ -> True) inv)
: Read bool (True) (fun _ -> True) inv
= let x = f () in
let x = f () in
let x = f () in
false | {
"file_name": "examples/layeredeffects/LowParseWriters.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 519,
"start_col": 0,
"start_line": 512
} | (*
Copyright 2019 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": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParseWriters.LowParse.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked"... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"... | {
"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 | inv: LowParseWriters.memory_invariant -> f: (_: Prims.unit -> LowParseWriters.Read Prims.bool)
-> LowParseWriters.Read Prims.bool | LowParseWriters.Read | [] | [] | [
"LowParseWriters.memory_invariant",
"Prims.unit",
"Prims.bool",
"Prims.l_True"
] | [] | false | true | false | false | false | let test_read3 (inv: memory_invariant) (f: (unit -> Read bool (True) (fun _ -> True) inv))
: Read bool (True) (fun _ -> True) inv =
| let x = f () in
let x = f () in
let x = f () in
false | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.